public TimeGenerator() { time = SystemClock.Instance.Now; _rnd = new RandomProvider(); _rnd.Reset((int)time.Ticks); }
/// <inheritdoc /> public override ZoneInterval GetZoneInterval(Instant instant) { int lower = 0; // Inclusive int upper = Intervals.Count; // Exclusive while (lower < upper) { int current = (lower + upper) / 2; var candidate = Intervals[current]; if (candidate.HasStart && candidate.Start > instant) { upper = current; } else if (candidate.HasEnd && candidate.End <= instant) { lower = current + 1; } else { return candidate; } } // Note: this would indicate a bug. The time zone is meant to cover the whole of time. throw new InvalidOperationException(string.Format("Instant {0} did not exist in time zone {1}", instant, Id)); }
/// <summary> /// Gets the zone offset period for the given instant. /// </summary> /// <param name="instant">The Instant to find.</param> /// <returns>The ZoneInterval including the given instant.</returns> public override ZoneInterval GetZoneInterval(Instant instant) { if (tailZone != null && instant >= tailZoneStart) { // Clamp the tail zone interval to start at the end of our final period, if necessary, so that the // join is seamless. ZoneInterval intervalFromTailZone = tailZone.GetZoneInterval(instant); return intervalFromTailZone.RawStart < tailZoneStart ? firstTailZoneInterval : intervalFromTailZone; } int lower = 0; // Inclusive int upper = periods.Length; // Exclusive while (lower < upper) { int current = (lower + upper) / 2; var candidate = periods[current]; if (candidate.RawStart > instant) { upper = current; } // Safe to use RawEnd, as it's just for the comparison. else if (candidate.RawEnd <= instant) { lower = current + 1; } else { return candidate; } } // Note: this would indicate a bug. The time zone is meant to cover the whole of time. throw new InvalidOperationException($"Instant {instant} did not exist in time zone {Id}"); }
public void MinusOffset_Zero_IsNeutralElement() { Instant sampleInstant = new Instant(1, 23456L); LocalInstant sampleLocalInstant = new LocalInstant(1, 23456L); Assert.AreEqual(sampleInstant, sampleLocalInstant.Minus(Offset.Zero)); Assert.AreEqual(sampleInstant, sampleLocalInstant.MinusZeroOffset()); }
/// <summary> /// Initializes a new instance of the <see cref="ZoneTransition"/> class. /// </summary> /// <remarks> /// </remarks> /// <param name="instant">The instant that this transistion occurs at.</param> /// <param name="name">The name for the time at this transition e.g. PDT or PST.</param> /// <param name="standardOffset">The standard offset at this transition.</param> /// <param name="savings">The actual offset at this transition.</param> internal ZoneTransition(Instant instant, String name, Offset standardOffset, Offset savings) { Preconditions.CheckNotNull(name, "name"); this.Instant = instant; this.Name = name; this.StandardOffset = standardOffset; this.Savings = savings; }
/// <summary> /// Creates a zone with a single transition between two offsets. /// </summary> /// <param name="transitionPoint">The transition point as an <see cref="Instant"/>.</param> /// <param name="offsetBefore">The offset of local time from UTC before the transition.</param> /// <param name="offsetAfter">The offset of local time from UTC before the transition.</param> /// <param name="id">ID for the newly created time zone.</param> public SingleTransitionDateTimeZone(Instant transitionPoint, Offset offsetBefore, Offset offsetAfter, string id) : base(id, false, Offset.Min(offsetBefore, offsetAfter), Offset.Max(offsetBefore, offsetAfter)) { EarlyInterval = new ZoneInterval(id + "-Early", null, transitionPoint, offsetBefore, Offset.Zero); LateInterval = new ZoneInterval(id + "-Late", transitionPoint, null, offsetAfter, Offset.Zero); }
/// <summary> /// Creates a zone with a single transition between two offsets. /// </summary> /// <param name="transitionPoint">The transition point as an <see cref="Instant"/>.</param> /// <param name="offsetBefore">The offset of local time from UTC before the transition.</param> /// <param name="offsetAfter">The offset of local time from UTC before the transition.</param> public SingleTransitionZone(Instant transitionPoint, Offset offsetBefore, Offset offsetAfter) : base("Single", false, Offset.Min(offsetBefore, offsetAfter), Offset.Max(offsetBefore, offsetAfter)) { earlyInterval = new ZoneInterval("Single-Early", Instant.MinValue, transitionPoint, offsetBefore, Offset.Zero); lateInterval = new ZoneInterval("Single-Late", transitionPoint, Instant.MaxValue, offsetAfter, Offset.Zero); }
public void Construction() { // 10 million ticks = 1 second... Instant instant = new Instant(10000000); // Epoch is 1970 UTC // An instant isn't really "in" a time zone or calendar, but // it's convenient to consider UTC in the ISO-8601 calendar. Assert.AreEqual("1970-01-01T00:00:01Z", instant.ToString()); }
public void AdditionWithDuration() { // Some arbitrary instant. I've no idea when. Instant instant = new Instant(150000000); // A very short duration: a duration is simply a number of ticks. Duration duration = new Duration(1000); Instant later = instant + duration; Assert.AreEqual(new Instant(150001000), later); }
public CountdownActor(Label lbl, Form1 form, Instant deadline) { _labelUpdater = Context.ActorOf(Props.Create(() => new LabelUpdaterActor(lbl))); _alarm = Context.ActorOf(Props.Create(() => new AlarmActor(form))); _deadline = deadline; Receive<DateTime>(msg => UpdateDeadline(msg)); Receive<object>(msg => Tick()); }
internal PartialZoneIntervalMap(Instant start, Instant end, IZoneIntervalMap map) { // Allowing empty maps makes life simpler. Preconditions.DebugCheckArgument(start <= end, nameof(end), "Invalid start/end combination: {0} - {1}", start, end); this.Start = start; this.End = end; this.map = map; }
public void Construct_EndOfTime_Truncated() { const string name = "abc"; var instant = new Instant(Instant.MaxValue.Ticks + minusOneHour.TotalTicks); var actual = new ZoneTransition(instant, name, threeHours, threeHours); Assert.AreEqual(instant, actual.Instant, "Instant"); Assert.AreEqual(oneHour, actual.StandardOffset, "StandardOffset"); Assert.AreEqual(Offset.Zero, actual.Savings, "Savings"); }
public void Comparison() { Instant equal = new Instant(1, 100L); Instant greater1 = new Instant(1, 101L); Instant greater2 = new Instant(2, 0L); TestHelper.TestCompareToStruct(equal, equal, greater1); TestHelper.TestNonGenericCompareTo(equal, equal, greater1); TestHelper.TestOperatorComparisonEquality(equal, equal, greater1, greater2); }
public void SingleAggregateSchedule() { Instant i = new Instant(Tester.RandomGenerator.RandomInt32()); OneOffSchedule oneOffSchedule = new OneOffSchedule(i); AggregateSchedule aggregateSchedule = new AggregateSchedule(oneOffSchedule); Assert.AreEqual(1, aggregateSchedule.Count()); Assert.AreEqual(i, aggregateSchedule.Next(i - TimeHelpers.OneSecond)); Assert.AreEqual(i, aggregateSchedule.Next(i)); Assert.AreEqual(Instant.MaxValue, aggregateSchedule.Next(i + Duration.FromTicks(1))); }
public Duration KeepAlive(Instant now) { var newTimestamp = now; var oldTimestamp = this.LastKeepAlive; this.LastKeepAlive = newTimestamp; var lag = newTimestamp - oldTimestamp; return lag; }
/// <summary> /// Gets the zone interval for the given instant. /// </summary> /// <param name="instant">The Instant to test.</param> /// <returns>The ZoneInterval in effect at the given instant.</returns> /// <exception cref="ArgumentOutOfRangeException">The instant falls outside the bounds /// of the recurrence rules of the zone.</exception> public override ZoneInterval GetZoneInterval(Instant instant) { ZoneRecurrence recurrence; var next = NextTransition(instant, out recurrence); // Now we know the recurrence we're in, we can work out when we went into it. (We'll never have // two transitions into the same recurrence in a row.) Offset previousSavings = ReferenceEquals(recurrence, standardRecurrence) ? dstRecurrence.Savings : Offset.Zero; var previous = recurrence.PreviousOrSameOrFail(instant, standardOffset, previousSavings); return new ZoneInterval(recurrence.Name, previous.Instant, next.Instant, standardOffset + recurrence.Savings, recurrence.Savings); }
public void Update(UpdateEventArgs args) { var elapsedTime = new TimeSpan(args.ElapsedTimeInS); this.time += elapsedTime; foreach (var gameObject in this.gameObjects) { gameObject.Update(elapsedTime); } }
public void Max() { Instant x = new Instant(100); Instant y = new Instant(200); Assert.AreEqual(y, Instant.Max(x, y)); Assert.AreEqual(y, Instant.Max(y, x)); Assert.AreEqual(x, Instant.Max(x, Instant.MinValue)); Assert.AreEqual(x, Instant.Max(Instant.MinValue, x)); Assert.AreEqual(Instant.MaxValue, Instant.Max(Instant.MaxValue, x)); Assert.AreEqual(Instant.MaxValue, Instant.Max(x, Instant.MaxValue)); }
public void Equality() { Instant equal = new Instant(1, 100L); Instant different1 = new Instant(1, 200L); Instant different2 = new Instant(2, 100L); TestHelper.TestEqualsStruct(equal, equal, different1); TestHelper.TestOperatorEquality(equal, equal, different1); TestHelper.TestEqualsStruct(equal, equal, different2); TestHelper.TestOperatorEquality(equal, equal, different2); }
public void TestInstantOperators() { const long diff = TestTime2 - TestTime1; var time1 = new Instant(TestTime1); var time2 = new Instant(TestTime2); Duration duration = time2 - time1; Assert.AreEqual(diff, duration.Ticks); Assert.AreEqual(TestTime2, (time1 + duration).Ticks); Assert.AreEqual(TestTime1, (time2 - duration).Ticks); }
/// <summary> /// Initializes a new instance of the <see cref="ScheduledActionResult"/> class. /// </summary> /// <param name="due">The due.</param> /// <param name="started">The started.</param> /// <param name="duration">The duration.</param> /// <param name="exception">The exception.</param> /// <param name="cancelled">if set to <see langword="true"/> the action was cancelled.</param> /// <remarks></remarks> protected ScheduledActionResult( Instant due, Instant started, Duration duration, [CanBeNull] Exception exception, bool cancelled) { Due = due; Started = started; Duration = duration; Exception = exception; Cancelled = cancelled; }
private static void TestToStringBase(Instant value, string gvalue) { string actual = value.ToString(); Assert.AreEqual(gvalue, actual); actual = value.ToString("g", null); Assert.AreEqual(gvalue, actual); actual = value.ToString("g", CultureInfo.InvariantCulture); Assert.AreEqual(gvalue, actual); actual = string.Format("{0}", value); Assert.AreEqual(gvalue, actual); actual = string.Format("{0:g}", value); Assert.AreEqual(gvalue, actual); }
public void DoubleAggregateSchedule() { Instant i = new Instant(Tester.RandomGenerator.RandomInt32()); Instant j = i + TimeHelpers.OneSecond; OneOffSchedule s1 = new OneOffSchedule(i); OneOffSchedule s2 = new OneOffSchedule(j); AggregateSchedule aggregateSchedule = new AggregateSchedule(s1, s2); Assert.AreEqual(2, aggregateSchedule.Count()); Assert.AreEqual(i, aggregateSchedule.Next(i - TimeHelpers.OneSecond)); Assert.AreEqual(i, aggregateSchedule.Next(i)); Assert.AreEqual(j, aggregateSchedule.Next(i + Duration.FromTicks(1))); Assert.AreEqual(j, aggregateSchedule.Next(j)); Assert.AreEqual(Instant.MaxValue, aggregateSchedule.Next(j + Duration.FromTicks(1))); }
internal PrecalculatedDateTimeZone([NotNull] string id, [NotNull] ZoneInterval[] intervals, IZoneIntervalMapWithMinMax tailZone) : base(id, false, ComputeOffset(intervals, tailZone, Offset.Min), ComputeOffset(intervals, tailZone, Offset.Max)) { this.tailZone = tailZone; this.periods = intervals; this.tailZone = tailZone; this.tailZoneStart = intervals[intervals.Length - 1].RawEnd; // We want this to be AfterMaxValue for tail-less zones. if (tailZone != null) { // Cache a "clamped" zone interval for use at the start of the tail zone. firstTailZoneInterval = tailZone.GetZoneInterval(tailZoneStart).WithStart(tailZoneStart); } ValidatePeriods(intervals, tailZone); }
private static string ConvertNowLine(string line, Instant runTime) { var match = NowRegex.Match(line); if (!match.Success) { throw new Exception("Invalid line: " + line); } var local = LocalPattern.Parse(match.Groups["local"].Value.Replace(" ", " ")).Value; var name = match.Groups["name"].Value; var offsetAsDuration = local.InUtc().ToInstant() - runTime; // Round it to the nearest 5 minutes. var roundedSeconds = Math.Round(offsetAsDuration.TotalSeconds / 300) * 300; var offset = Offset.FromSeconds((int) roundedSeconds); return string.Format("Fixed: {0} {1}\r\n", OffsetPattern.Format(offset), name); }
internal ZoneInterval GetZoneInterval(Instant instant) { Preconditions.DebugCheckArgument(instant >= Start && instant < End, nameof(instant), "Value {0} was not in the range [{0}, {1})", instant, Start, End); var interval = map.GetZoneInterval(instant); // Clamp the interval for the sake of sanity. Checking this every time isn't very efficient, // but we're not expecting this to be called too often, due to caching. if (interval.RawStart < Start) { interval = interval.WithStart(Start); } if (interval.RawEnd > End) { interval = interval.WithEnd(End); } return interval; }
/// <summary> /// Initializes the <see cref="HighPrecisionClock"/> class. /// </summary> static HighPrecisionClock() { try { long time; GetSystemTimePreciseAsFileTime(out time); _getSysTimeAvailable = true; } catch (Exception) { _getSysTimeAvailable = false; if (Stopwatch.IsHighResolution) { // ReSharper disable once PossibleNullReferenceException _startedTime = SystemClock.Instance.Now; _startedTicks = Stopwatch.GetTimestamp(); } } }
/// <summary> /// Gets the zone offset period for the given instant. Null is returned if no period is /// defined by the time zone for the given instant. /// </summary> /// <param name="instant">The Instant to test.</param> /// <returns>The defined ZoneOffsetPeriod or null.</returns> public ZoneInterval GetZoneInterval(Instant instant) { int period = instant.DaysSinceEpoch >> PeriodShift; int index = period & CachePeriodMask; var node = instantCache[index]; if (node == null || node.Period != period) { node = HashCacheNode.CreateNode(period, map); instantCache[index] = node; } // Note: moving this code into an instance method in HashCacheNode makes a surprisingly // large performance difference. while (node.Previous != null && node.Interval.RawStart > instant) { node = node.Previous; } return node.Interval; }
private static void TestToStringBase(Instant value, string gvalue) { string actual = value.ToString(); Assert.AreEqual(gvalue, actual); actual = value.ToString("G"); Assert.AreEqual(gvalue, actual); actual = value.ToString("N"); Assert.AreEqual(value.Ticks.ToString("N0"), actual); actual = value.ToString("N", CultureInfo.InvariantCulture); Assert.AreEqual(value.Ticks.ToString("N0", CultureInfo.InvariantCulture), actual); actual = value.ToString(CultureInfo.InvariantCulture); Assert.AreEqual(gvalue, actual); actual = value.ToString("D"); Assert.AreEqual(value.Ticks.ToString("D"), actual); actual = string.Format("{0}", value); Assert.AreEqual(gvalue, actual); actual = string.Format("{0:G}", value); Assert.AreEqual(gvalue, actual); actual = string.Format("{0:N}", value); Assert.AreEqual(value.Ticks.ToString("N0"), actual); actual = string.Format("{0:D}", value); Assert.AreEqual(value.Ticks.ToString("D"), actual); }
/// <summary> /// Should be greater or equal to the given <see cref="Instant" /> /// </summary> /// <param name="expected"></param> /// <param name="because"></param> /// <param name="becauseArgs"></param> /// <returns></returns> public AndConstraint <InstantAssertions> BeGreaterOrEqualTo(Instant expected, string because = "", params object[] becauseArgs) { return(ExecuteAssertion(Subject >= expected, "to be greater than or equal to", expected, because, becauseArgs)); }
/// <summary> /// Should be less than the given <see cref="Instant" /> /// </summary> /// <param name="expected"></param> /// <param name="because"></param> /// <param name="becauseArgs"></param> /// <returns></returns> public AndConstraint <InstantAssertions> BeLessThan(Instant expected, string because = "", params object[] becauseArgs) { return(ExecuteAssertion(Subject < expected, "to be less than", expected, because, becauseArgs)); }
public static Instant AsInstant(this Instant value) { return(value); }
private static void UpdateVersionTimestamp(StreetNameDetail streetName, Instant versionTimestamp) => streetName.VersionTimestamp = versionTimestamp;
public string GetRelativeTime(Instant start, Instant end) { return(GetRelativeTime(start.InUtc().LocalDateTime, end.InUtc().LocalDateTime)); }
private void ChangeStatusScheduled(ChangeContentStatus command, Instant dueTime) { Raise(command, new ContentStatusScheduled { DueTime = dueTime }); }
/// <summary> /// Should not be the given <see cref="Instant" /> /// </summary> /// <param name="expected"></param> /// <param name="because"></param> /// <param name="becauseArgs"></param> /// <returns></returns> public AndConstraint <InstantAssertions> NotBe(Instant expected, string because = "", params object[] becauseArgs) { return(ExecuteAssertion(!Subject.HasValue || Subject != expected, "to not be", expected, because, becauseArgs)); }
private static Instant FutureDays(int days) { return(Instant.FromDateTimeUtc(DateTime.UtcNow.Date.AddDays(days))); }
public static User Hypdrate(int id, Guid accessToken, string name, string emailHash, string countryCode, Instant createdDate) { return(new User(id, accessToken, name, emailHash, countryCode, createdDate)); }
public void NodaTimeInstant_ParsesVariousValues(string input, Instant expected) { var actual = input.FromJson <Instant>(); Assert.That(actual, Is.EqualTo(expected)); }
public static User From(string name, string emailHash, string countryCode, Instant createdDate) { return(new User(null, Guid.NewGuid(), name, emailHash, countryCode, createdDate)); }
public User(int?id, Guid accessToken, string name, string emailHash, string countryCode, Instant createdDate) { Id = id; AccessToken = accessToken; Name = name; EmailHash = emailHash; CountryCode = countryCode; CreatedDate = createdDate; }
public async IAsyncEnumerable <StoredEvent> QueryAllReverseAsync(string?streamFilter = null, Instant timestamp = default, int take = int.MaxValue, [EnumeratorCancellation] CancellationToken ct = default) { if (take <= 0) { yield break; } StreamPosition lastPosition = timestamp; var filterDefinition = CreateFilter(streamFilter, lastPosition); var find = Collection.Find(filterDefinition, Batching.Options) .Limit(take).Sort(Sort.Descending(TimestampField).Ascending(EventStreamField)); var taken = 0; using (var cursor = await find.ToCursorAsync(ct)) { while (taken < take && await cursor.MoveNextAsync(ct)) { foreach (var current in cursor.Current) { foreach (var @event in current.Filtered(lastPosition).Reverse()) { yield return(@event); taken++; if (taken == take) { break; } } if (taken == take) { break; } } } } }
public void SetUp() { testDescriptorDigest = DescriptorDigest.FromHash( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); Mock.Get(mockBuildConfiguration).Setup(m => m.GetEventHandlers()).Returns(mockEventHandlers); Mock.Get(mockBuildConfiguration).Setup(m => m.GetContainerConfiguration()).Returns(mockContainerConfiguration); Mock.Get(mockBuildConfiguration).Setup(m => m.GetToolName()).Returns(() => null); Mock.Get(mockContainerConfiguration).Setup(m => m.GetCreationTime()).Returns(Instant.FromUnixTimeSeconds(0)); Mock.Get(mockContainerConfiguration).Setup(m => m.GetEnvironmentMap()).Returns(ImmutableDictionary.Create <string, string>()); Mock.Get(mockContainerConfiguration).Setup(m => m.GetProgramArguments()).Returns(ImmutableArray.Create <string>()); Mock.Get(mockContainerConfiguration).Setup(m => m.GetExposedPorts()).Returns(ImmutableHashSet.Create <Port>()); Mock.Get(mockContainerConfiguration).Setup(m => m.GetEntrypoint()).Returns(ImmutableArray.Create <string>()); Mock.Get(mockContainerConfiguration).Setup(m => m.GetUser()).Returns("root"); Mock.Get(mockCachedLayer).Setup(m => m.GetBlobDescriptor()).Returns(new BlobDescriptor(0, testDescriptorDigest)); nonEmptyLayerHistory = HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("FibBase") .SetCreatedBy("fib-test") .Build(); emptyLayerHistory = HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("FibBase") .SetCreatedBy("fib-test") .SetEmptyLayer(true) .Build(); Image baseImage = Image.CreateBuilder(ManifestFormat.V22) .SetArchitecture("wasm") .SetOs("js") .AddEnvironment(ImmutableDic.Of("BASE_ENV", "BASE_ENV_VALUE", "BASE_ENV_2", "DEFAULT")) .AddLabel("base.label", "base.label.value") .AddLabel("base.label.2", "default") .SetWorkingDirectory("/base/working/directory") .SetEntrypoint(ImmutableArray.Create("baseImageEntrypoint")) .SetProgramArguments(ImmutableArray.Create("catalina.sh", "run")) .SetHealthCheck( DockerHealthCheck.FromCommand(ImmutableArray.Create("CMD-SHELL", "echo hi")) .SetInterval(Duration.FromSeconds(3)) .SetTimeout(Duration.FromSeconds(2)) .SetStartPeriod(Duration.FromSeconds(1)) .SetRetries(20) .Build()) .AddExposedPorts(ImmutableHashSet.Create(Port.Tcp(1000), Port.Udp(2000))) .AddVolumes( ImmutableHashSet.Create( AbsoluteUnixPath.Get("/base/path1"), AbsoluteUnixPath.Get("/base/path2"))) .AddHistory(nonEmptyLayerHistory) .AddHistory(emptyLayerHistory) .AddHistory(emptyLayerHistory) .Build(); Mock.Get(mockPullAndCacheBaseImageLayerStep).Setup(m => m.GetFuture()).Returns(Futures.ImmediateFutureAsync(mockCachedLayer)); Mock.Get(mockPullAndCacheBaseImageLayersStep).Setup(m => m.GetFuture()).Returns( Futures.ImmediateFutureAsync <IReadOnlyList <ICachedLayer> >( ImmutableArray.Create( mockCachedLayer, mockCachedLayer, mockCachedLayer))); Mock.Get(mockPullBaseImageStep).Setup(m => m.GetFuture()).Returns( Futures.ImmediateFutureAsync( new BaseImageWithAuthorization(baseImage, null))); mockClassesLayer = new CachedLayerWithType(mockCachedLayer, "classes"); mockDependenciesLayer = new CachedLayerWithType(mockCachedLayer, "dependencies"); mockExtraFilesLayer = new CachedLayerWithType(mockCachedLayer, "extra files"); mockResourcesLayer = new CachedLayerWithType(mockCachedLayer, "resources"); }
private static ZonedDateTime ParseZonedDateTime(string value) { var dateTime = DateTime.Parse(value); return(new ZonedDateTime(Instant.FromDateTimeUtc(dateTime.ToUniversalTime()), DateTimeZone.Utc)); }
public async Task Test_generateHistoryObjectsAsync() { Mock.Get(mockBuildAndCacheApplicationLayersStep).Setup(s => s.GetFuture()).Returns(Task.FromResult <IReadOnlyList <ICachedLayer> >(ImmutableArray.Create( mockDependenciesLayer, mockResourcesLayer, mockClassesLayer, mockExtraFilesLayer))); string createdBy = "fib:" + ProjectInfo.VERSION; BuildImageStep buildImageStep = new BuildImageStep( mockBuildConfiguration, ProgressEventDispatcher.NewRoot(mockEventHandlers, "ignored", 1).NewChildProducer(), mockPullBaseImageStep, mockPullAndCacheBaseImageLayersStep, mockBuildAndCacheApplicationLayersStep); Image image = await buildImageStep.GetFuture().ConfigureAwait(false); // Make sure history is as expected HistoryEntry expectedAddedBaseLayerHistory = HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetComment("auto-generated by Fib") .Build(); HistoryEntry expectedApplicationLayerHistoryDependencies = HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("Fib") .SetCreatedBy(createdBy) .SetComment("dependencies") .Build(); HistoryEntry expectedApplicationLayerHistoryResources = HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("Fib") .SetCreatedBy(createdBy) .SetComment("resources") .Build(); HistoryEntry expectedApplicationLayerHistoryClasses = HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("Fib") .SetCreatedBy(createdBy) .SetComment("classes") .Build(); HistoryEntry expectedApplicationLayerHistoryExtrafiles = HistoryEntry.CreateBuilder() .SetCreationTimestamp(Instant.FromUnixTimeSeconds(0)) .SetAuthor("Fib") .SetCreatedBy(createdBy) .SetComment("extra files") .Build(); // Base layers (1 non-empty propagated, 2 empty propagated, 2 non-empty generated) Assert.AreEqual(nonEmptyLayerHistory, image.GetHistory()[0]); Assert.AreEqual(emptyLayerHistory, image.GetHistory()[1]); Assert.AreEqual(emptyLayerHistory, image.GetHistory()[2]); Assert.AreEqual(expectedAddedBaseLayerHistory, image.GetHistory()[3]); Assert.AreEqual(expectedAddedBaseLayerHistory, image.GetHistory()[4]); // Application layers (4 generated) Assert.AreEqual(expectedApplicationLayerHistoryDependencies, image.GetHistory()[5]); Assert.AreEqual(expectedApplicationLayerHistoryResources, image.GetHistory()[6]); Assert.AreEqual(expectedApplicationLayerHistoryClasses, image.GetHistory()[7]); Assert.AreEqual(expectedApplicationLayerHistoryExtrafiles, image.GetHistory()[8]); // Should be exactly 9 total Assert.AreEqual(9, image.GetHistory().Length); }
public Task ScheduleGroupedAsync(string key, T job, Instant dueTime, bool canInline, CancellationToken ct = default) { return(scheduling.ScheduleGroupedAsync(key, job, dueTime, canInline, ct)); }
public static TimeSpan LocalTimeSpanFromUnixTime(this long unixTimeSeconds) { var localTime = Instant.FromUnixTimeSeconds(unixTimeSeconds).InZone(Zone); return(new TimeSpan(localTime.Hour, localTime.Minute, 00)); }
private static void UpdateVersionTimestamp(MunicipalityDetail municipality, Instant versionTimestamp) => municipality.VersionTimestamp = versionTimestamp;
public void UpdateLastUsedCredentials(Instant currentInstant) { LastChangedCredentials = currentInstant; }
public string GetRelativeTime(Instant instant) { return(GetRelativeTime(instant, SystemClock.Instance)); }
internal bool haveAlreadySentReport(Instant mostRecentReportBillingDate, SolarAndUtilityReport report) { return(!(mostRecentReportBillingDate.InZone(reportTimeZone).Date < report.billingDate)); }
public bool Contains(Instant instant) => RawStart <= instant && instant < RawEnd;
// Type is created as immutable to avoid problems with accidental changes to in-memory cache public JobProgress(Instant nextIterationStart, Instant nextIterationEnd, string nextToken) { NextIterationStart = nextIterationStart; NextIterationEnd = nextIterationEnd; NextToken = nextToken; }
/// <summary> /// Returns a copy of this zone interval, but with the given end instant. /// </summary> internal ZoneInterval WithEnd(Instant newEnd) { return(new ZoneInterval(Name, RawStart, newEnd, WallOffset, Savings)); }
/// <summary> /// Create new <see cref="Prayer" />. /// </summary> public Prayer(PrayerType type, Instant time) { Type = type; Time = time; }
/// <summary> /// Returns a copy of this zone interval, but with the given start instant. /// </summary> internal ZoneInterval WithStart(Instant newStart) { return(new ZoneInterval(Name, newStart, RawEnd, WallOffset, Savings)); }
public void NodaTimeInstant_SerializesToExpectedText(Instant input, string expected) { var actual = input.ToJson(); Assert.That(actual, Is.EqualTo(expected)); }
public override string ToString() { return(Instant.FromDateTimeOffset(new DateTimeOffset(Year, Month, Day, Hour, Minute, Second, TimeSpan.Zero)).ToString()); }
public void WriteZoneIntervalTransition(Instant? previous, Instant value) { if (previous != null) { Preconditions.CheckArgument(value >= previous.Value, nameof(value), "Transition must move forward in time"); } unchecked { if (value == Instant.BeforeMinValue) { WriteCount(ZoneIntervalConstants.MarkerMinValue); return; } if (value == Instant.AfterMaxValue) { WriteCount(ZoneIntervalConstants.MarkerMaxValue); return; } // In practice, most zone interval transitions will occur within 4000-6000 hours of the previous one // (i.e. about 5-8 months), and at an integral number of hours difference. We therefore gain a // significant reduction in output size by encoding transitions as the whole number of hours since the // previous, if possible. // If the previous value was "the start of time" then there's no point in trying to use it. if (previous != null && previous.Value != Instant.BeforeMinValue) { // Note that the difference might exceed the range of a long, so we can't use a Duration here. ulong ticks = (ulong) (value.Ticks - previous.Value.Ticks); if (ticks % TicksPerHour == 0) { ulong hours = ticks / TicksPerHour; // As noted above, this will generally fall within the 4000-6000 range, although values up to // ~700,000 exist in TZDB. if (ZoneIntervalConstants.MinValueForHoursSincePrevious <= hours && hours < ZoneIntervalConstants.MinValueForMinutesSinceEpoch) { WriteCount((int) hours); return; } } } // We can't write the transition out relative to the previous transition, so let's next try writing it // out as a whole number of minutes since an (arbitrary, known) epoch. if (value >= ZoneIntervalConstants.EpochForMinutesSinceEpoch) { ulong ticks = (ulong) (value.Ticks - ZoneIntervalConstants.EpochForMinutesSinceEpoch.Ticks); if (ticks % TicksPerMinute == 0) { ulong minutes = ticks / TicksPerMinute; // We typically have a count on the order of 80M here. if (ZoneIntervalConstants.MinValueForMinutesSinceEpoch < minutes && minutes <= int.MaxValue) { WriteCount((int) minutes); return; } } } // Otherwise, just write out a marker followed by the instant as a 64-bit number of ticks. Note that // while most of the values we write here are actually whole numbers of _seconds_, optimising for that // case will save around 2KB (with tzdb 2012j), so doesn't seem worthwhile. WriteCount(ZoneIntervalConstants.MarkerRaw); WriteInt64(value.Ticks); } }
public FantasyCriticUser(Guid userID, string userName, string normalizedUserName, string emailAddress, string normalizedEmailAddress, bool emailConfirmed, string securityStamp, string passwordHash, Instant lastChangedCredentials) { UserID = userID; UserName = userName; NormalizedUserName = normalizedUserName; EmailAddress = emailAddress; NormalizedEmailAddress = normalizedEmailAddress; EmailConfirmed = emailConfirmed; SecurityStamp = securityStamp; PasswordHash = passwordHash; LastChangedCredentials = lastChangedCredentials; }