Exemple #1
0
        public void TestEquality()
        {
            Duration first  = new Duration(5, 565.0);
            Duration second = new Duration(5, 565.0);

            Assert.AreEqual(first, second);
            Assert.IsTrue(first.Equals(second));
            Assert.IsTrue(second.Equals(first));
            Assert.IsTrue(first == second);
            Assert.IsTrue(second == first);
            Assert.IsFalse(first != second);
            Assert.IsFalse(second != first);
            Assert.AreEqual(0, first.CompareTo(second));
            Assert.AreEqual(0, second.CompareTo(first));

            first  = new Duration(5, 0.00001);
            second = new Duration(4, 86399.99999);
            Assert.AreNotEqual(first, second);
            Assert.IsFalse(first.Equals(second));
            Assert.IsFalse(second.Equals(first));
            Assert.IsFalse(first == second);
            Assert.IsFalse(second == first);
            Assert.IsTrue(first != second);
            Assert.IsTrue(second != first);
            Assert.AreNotEqual(0, first.CompareTo(second));
            Assert.AreNotEqual(0, second.CompareTo(first));
            Assert.IsTrue(first.EqualsEpsilon(second, 1e-4));
            Assert.IsTrue(second.EqualsEpsilon(first, 1e-4));

            // Make sure a Duration compared with a non-Duration returns false
            Assert.IsFalse(first.Equals(5));
        }
        public void EqualsIsImplemented()
        {
            Duration v = Duration.FromSeconds(1);

            Assert.IsTrue(v.Equals(Duration.FromSeconds(1)));
            Assert.IsFalse(v.Equals(Duration.Zero));
        }
        public void EqualsIsImplemented()
        {
            Duration v = Duration.FromSeconds(1);

            Assert.True(v.Equals(Duration.FromSeconds(1), Duration.FromSeconds(SecondsTolerance)));
            Assert.False(v.Equals(Duration.Zero, Duration.FromSeconds(SecondsTolerance)));
        }
Exemple #4
0
        public void TestDurationClass()
        {
            var firstDuration  = new Duration(200, TimeUnit.Minutes);
            var secondDuration = new Duration(200, TimeUnit.Minutes);

            Check.That(firstDuration.RawDuration).IsEqualTo(200);
            Check.That(firstDuration.Unit).IsEqualTo(TimeUnit.Minutes);
            Check.That(firstDuration.ToString()).IsEqualTo("200 Minutes");
            Check.That(firstDuration > new Duration(100, TimeUnit.Seconds)).IsTrue();
            Check.That(firstDuration < new Duration(100, TimeUnit.Hours)).IsTrue();
            Check.That(firstDuration < secondDuration).IsFalse();
            Check.That(firstDuration <= secondDuration).IsTrue();
            Check.That(firstDuration > secondDuration).IsFalse();
            Check.That(firstDuration >= secondDuration).IsTrue();

            var anotherDurationWithSameValue = new Duration(200, TimeUnit.Minutes);

            // test objects override
            Check.That(firstDuration.GetHashCode()).IsEqualTo(anotherDurationWithSameValue.GetHashCode());
            Check.That(firstDuration).IsEqualTo(anotherDurationWithSameValue);
            Check.That(anotherDurationWithSameValue.Equals(firstDuration)).IsTrue();
            Check.That(anotherDurationWithSameValue == firstDuration).IsTrue();
            Check.That(anotherDurationWithSameValue.Equals(null)).IsFalse();
            // ReSharper disable once SuspiciousTypeConversion.Global
            Check.That(anotherDurationWithSameValue.Equals(20)).IsFalse();
            Check.That(anotherDurationWithSameValue.Equals((object)firstDuration)).IsTrue();

            Check.That(firstDuration.GetHashCode()).IsEqualTo(-259084257);
        }
Exemple #5
0
 public void Equals_Object_ReturnsExpected(Duration duration, object other, int expected)
 {
     Assert.Equal(expected == 0, duration.Equals(other));
     if (other is Duration otherDuration)
     {
         Assert.Equal(expected == 0, Duration.Equals(duration, otherDuration));
         Assert.Equal(expected == 0, duration.Equals(otherDuration));
         Assert.Equal(expected == 0, duration.GetHashCode().Equals(otherDuration.GetHashCode()));
     }
 }
        public void ShouldNotBeEqualToNull()
        {
            var duration = new Duration(15, 32, 785, 789215800);
            var other    = (object)null;

            duration.Equals(other).Should().BeFalse();
        }
Exemple #7
0
        /// <summary>
        /// Returns true if ResponseDiscoveryOutageListData instances are equal
        /// </summary>
        /// <param name="other">Instance of ResponseDiscoveryOutageListData to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(ResponseDiscoveryOutageListData other)
        {
            if (ReferenceEquals(null, other))
            {
                return(false);
            }
            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            return
                ((
                     OutageTime == other.OutageTime ||
                     OutageTime != null &&
                     OutageTime.Equals(other.OutageTime)
                     ) &&
                 (
                     Duration == other.Duration ||
                     Duration != null &&
                     Duration.Equals(other.Duration)
                 ) &&
                 (
                     IsPartial == other.IsPartial ||
                     IsPartial != null &&
                     IsPartial.Equals(other.IsPartial)
                 ) &&
                 (
                     Explanation == other.Explanation ||
                     Explanation != null &&
                     Explanation.Equals(other.Explanation)
                 ));
        }
        /// <summary>
        /// Returns true if Stop instances are equal
        /// </summary>
        /// <param name="input">Instance of Stop to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(Stop input)
        {
            if (input == null)
            {
                return(false);
            }

            return
                ((
                     Address == input.Address ||
                     (Address != null &&
                      Address.Equals(input.Address))
                     ) &&
                 (
                     Duration == input.Duration ||
                     (Duration != null &&
                      Duration.Equals(input.Duration))
                 ) &&
                 (
                     PreparationTime == input.PreparationTime ||
                     (PreparationTime != null &&
                      PreparationTime.Equals(input.PreparationTime))
                 ) &&
                 (
                     TimeWindows == input.TimeWindows ||
                     TimeWindows != null &&
                     TimeWindows.SequenceEqual(input.TimeWindows)
                 ));
        }
        public void ShouldNotBeEqualToAnotherType()
        {
            var duration = new Duration(15, 32, 785, 789215800);
            var other    = "some string";

            duration.Equals(other).Should().BeFalse();
        }
Exemple #10
0
        /// <summary>
        /// Indicates whether the current object is equal to another object of type <see cref="PeriodicSchedule"/>.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>
        /// true if the current object is equal to the <paramref name="other" /> parameter; otherwise, false.
        /// </returns>
        public bool Equals(PeriodicSchedule other)
        {
            if (ReferenceEquals(null, other))
            {
                return(false);
            }
            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            return(Options == other.Options &&
                   Day == other.Day &&
                   FirstDayOfWeek == other.FirstDayOfWeek &&
                   Hour == other.Hour &&
                   Minute == other.Minute &&
                   Month == other.Month &&
                   Second == other.Second &&
                   Week == other.Week &&
                   WeekDay == other.WeekDay &&
                   MinimumGap.Equals(other.MinimumGap) &&
                   string.Equals(Name, other.Name) &&
                   CalendarSystem.Equals(other.CalendarSystem) &&
                   DateTimeZone.Equals(other.DateTimeZone));
        }
        public void ShouldNotBeEqual()
        {
            var duration1 = new Duration(15, 32, 785, 789215800);
            var duration2 = new Duration(15, 32, 786, 789215800);

            duration1.Equals(duration2).Should().BeFalse();
        }
Exemple #12
0
        public void TestDNO()
        {
            string description = "This is a fast rotation plan that uses 3 teams and two 12-hr shifts to provide 24/7 coverage. "
                                 + "Each team rotates through the following sequence every three days: 1 day shift, 1 night shift, and 1 day off.";

            schedule = new WorkSchedule("DNO Plan", description);

            // Day shift, starts at 07:00 for 12 hours
            Shift day = schedule.CreateShift("Day", "Day shift", new LocalTime(7, 0, 0), Duration.FromHours(12));

            // Night shift, starts at 19:00 for 12 hours
            Shift night = schedule.CreateShift("Night", "Night shift", new LocalTime(19, 0, 0), Duration.FromHours(12));

            // rotation
            Rotation rotation = schedule.CreateRotation("DNO", "DNO");

            rotation.AddSegment(day, 1, 0);
            rotation.AddSegment(night, 1, 1);

            schedule.CreateTeam("Team 1", "First team", rotation, referenceDate);
            schedule.CreateTeam("Team 2", "Second team", rotation, referenceDate.PlusDays(-1));
            schedule.CreateTeam("Team 3", "Third team", rotation, referenceDate.PlusDays(-2));

            // rotation working time
            LocalDateTime from     = referenceDate.PlusDays(rotation.GetDayCount()).At(new LocalTime(7, 0, 0));
            Duration      duration = schedule.CalculateWorkingTime(from, from.PlusDays(3));

            Assert.IsTrue(duration.Equals(Duration.FromHours(72)));

            RunBaseTest(schedule, Duration.FromHours(24), Duration.FromDays(3), referenceDate);
        }
Exemple #13
0
        /// <inheritdoc />
        public bool Equals([AllowNull] Transition other)
        {
            if (other == null)
            {
                return(false);
            }
            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            return
                ((
                     Duration == other.Duration ||
                     Duration != null &&
                     Duration.Equals(other.Duration)
                     ) &&
                 (
                     Easing == other.Easing ||
                     Easing != null &&
                     Easing.Equals(other.Easing)
                 ) &&
                 (
                     Ordering == other.Ordering ||
                     Ordering != null &&
                     Ordering.Equals(other.Ordering)
                 ));
        }
Exemple #14
0
 private static void EqualsTest(Duration a, Duration b)
 {
     Assert.AreEqual(a, b);
     Assert.True(a == b);
     Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
     Assert.False(a.Equals(null));
 }
Exemple #15
0
 public bool Equals(LogItemViewModel other)
 {
     if (ReferenceEquals(null, other))
     {
         return(false);
     }
     if (ReferenceEquals(this, other))
     {
         return(true);
     }
     return(RepresentedTimeEntriesIds.SequenceEqual(other.RepresentedTimeEntriesIds) &&
            IsBillable == other.IsBillable &&
            IsActive == other.IsActive &&
            string.Equals(Description, other.Description) &&
            string.Equals(ProjectName, other.ProjectName) &&
            string.Equals(ProjectColor, other.ProjectColor) &&
            string.Equals(ClientName, other.ClientName) &&
            string.Equals(TaskName, other.TaskName) &&
            Duration.Equals(other.Duration) &&
            HasProject == other.HasProject &&
            HasTags == other.HasTags &&
            NeedsSync == other.NeedsSync &&
            CanContinue == other.CanContinue &&
            VisualizationIntent == other.VisualizationIntent);
 }
Exemple #16
0
 private bool Equals(IDEEvent other)
 {
     return(string.Equals(Id, other.Id) && string.Equals(IDESessionUUID, other.IDESessionUUID) &&
            string.Equals(KaVEVersion, other.KaVEVersion) && TriggeredAt.Equals(other.TriggeredAt) &&
            TriggeredBy == other.TriggeredBy && Duration.Equals(other.Duration) &&
            Equals(ActiveWindow, other.ActiveWindow) && Equals(ActiveDocument, other.ActiveDocument));
 }
 private bool Equals(PeformanceCounterSetting other)
 {
     return(Duration.Equals(other.Duration) &&
            string.Equals(ValidationExpression, other.ValidationExpression) &&
            string.Equals(Instance, other.Instance) &&
            string.Equals(Name, other.Name) &&
            string.Equals(Category, other.Category) &&
            string.Equals(MachineName, other.MachineName));
 }
Exemple #18
0
 public override bool Equals(Object obj)
 {
     if (obj is OffsetClock)
     {
         OffsetClock other = (OffsetClock)obj;
         return(BaseClock.Equals(other.BaseClock) && Offset.Equals(other.Offset));
     }
     return(false);
 }
Exemple #19
0
        public T Update(GameTime gameTime, T start, T end, float duration, bool reverse = false, bool reset = false)
        {
            if (!Start.Equals(start) || !End.Equals(end) || !Duration.Equals(duration))
            {
                Init(start, end, duration, reset);
            }

            return(Update(gameTime, reverse));
        }
Exemple #20
0
 public bool Equals(SongInfo other)
 {
     return(Title.Equals(other.Title) &&
            Id.Equals(other.Id) &&
            Duration.Equals(other.Duration) &&
            DetailsLoaded == other.DetailsLoaded &&
            LiveStream == other.LiveStream
            );
 }
        public void Equals_ShouldNotBeEqual()
        {
            // arrange
            var a = new Duration(1, "some unit");
            var b = new Duration(2, "some other unit");

            // act & assert
            Assert.False(a.Equals(b));
        }
        public void Equals_ShouldBeEqual()
        {
            // arrange
            var a = new Duration(1, "some unit");
            var b = new Duration(1, "some unit");

            // act & assert
            Assert.True(a.Equals(b));
        }
 protected bool Equals(BuildTarget other)
 {
     return(string.Equals(Project, other.Project) &&
            string.Equals(ProjectConfiguration, other.ProjectConfiguration) &&
            string.Equals(Platform, other.Platform) &&
            string.Equals(SolutionConfiguration, other.SolutionConfiguration) &&
            StartedAt.Equals(other.StartedAt) && Duration.Equals(other.Duration) &&
            Successful.Equals(other.Successful));
 }
Exemple #24
0
        public T UpdateBySpeed(GameTime gameTime, T start, T end, float meanSpeed, bool reverse = false,
                               bool reset = false)
        {
            if (!Start.Equals(start) || !End.Equals(end) || !Duration.Equals(MeanSpeedToDuration(meanSpeed)))
            {
                InitBySpeed(start, end, meanSpeed, reset);
            }

            return(Update(gameTime, reverse));
        }
Exemple #25
0
 protected bool Equals(LogEntry other)
 {
     return(IssueNumber == other.IssueNumber &&
            Duration.Equals(other.Duration) &&
            string.Equals(Description, other.Description) &&
            string.Equals(Label, other.Label) &&
            string.Equals(Activity, other.Activity) &&
            string.Equals(Account, other.Account) &&
            CreateDate.Equals(other.CreateDate));
 }
Exemple #26
0
 //-------------------------------------------------------------------------
 /// <summary>
 /// Obtains a clock that returns instants from the specified clock with the
 /// specified duration added
 /// <para>
 /// This clock wraps another clock, returning instants that are later by the
 /// specified duration. If the duration is negative, the instants will be
 /// earlier than the current date and time.
 /// The main use case for this is to simulate running in the future or in the past.
 /// </para>
 /// <para>
 /// A duration of zero would have no offsetting effect.
 /// Passing zero will return the underlying clock.
 /// </para>
 /// <para>
 /// The returned implementation is immutable, thread-safe and {@code Serializable}
 /// providing that the base clock is.
 ///
 /// </para>
 /// </summary>
 /// <param name="baseClock">  the base clock to add the duration to, not null </param>
 /// <param name="offsetDuration">  the duration to add, not null </param>
 /// <returns> a clock based on the base clock with the duration added, not null </returns>
 public static Clock Offset(Clock baseClock, Duration offsetDuration)
 {
     Objects.RequireNonNull(baseClock, "baseClock");
     Objects.RequireNonNull(offsetDuration, "offsetDuration");
     if (offsetDuration.Equals(Duration.ZERO))
     {
         return(baseClock);
     }
     return(new OffsetClock(baseClock, offsetDuration));
 }
Exemple #27
0
        public void TestDurationClass()
        {
            var firstDuration = new Duration(200, TimeUnit.Minutes);

            Check.That(firstDuration.RawDuration).IsEqualTo(200);
            Check.That(firstDuration.Unit).IsEqualTo(TimeUnit.Minutes);
            Check.That(firstDuration.ToString()).IsEqualTo("200 Minutes");
            Check.That(firstDuration > new Duration(100, TimeUnit.Seconds)).IsTrue();
            Check.That(firstDuration < new Duration(100, TimeUnit.Hours)).IsTrue();

            var anotherDurationWithSameValue = new Duration(200, TimeUnit.Minutes);

            // test objects override
            Check.That(firstDuration.GetHashCode()).IsEqualTo(anotherDurationWithSameValue.GetHashCode());
            Check.That(firstDuration).IsEqualTo(anotherDurationWithSameValue);
            Check.That(anotherDurationWithSameValue.Equals(firstDuration)).IsTrue();
            Check.That(anotherDurationWithSameValue == firstDuration).IsTrue();
            Check.That(anotherDurationWithSameValue.Equals(null)).IsFalse();
            Check.That(anotherDurationWithSameValue.Equals(20)).IsFalse();
            Check.That(anotherDurationWithSameValue.Equals((object)firstDuration)).IsTrue();
        }
Exemple #28
0
        public void TestDurationClass()
        {
            var firstDuration = new Duration(200, TimeUnit.Minutes);
            
            Check.That(firstDuration.RawDuration).IsEqualTo(200);
            Check.That(firstDuration.Unit).IsEqualTo(TimeUnit.Minutes);
            Check.That(firstDuration.ToString()).IsEqualTo("200 Minutes");
            Check.That(firstDuration > new Duration(100, TimeUnit.Seconds)).IsTrue();
            Check.That(firstDuration < new Duration(100, TimeUnit.Hours)).IsTrue();

            var anotherDurationWithSameValue = new Duration(200, TimeUnit.Minutes);

            // test objects override
            Check.That(firstDuration.GetHashCode()).IsEqualTo(anotherDurationWithSameValue.GetHashCode());
            Check.That(firstDuration).IsEqualTo(anotherDurationWithSameValue);
            Check.That(anotherDurationWithSameValue.Equals(firstDuration)).IsTrue();
            Check.That(anotherDurationWithSameValue == firstDuration).IsTrue();
            Check.That(anotherDurationWithSameValue.Equals(null)).IsFalse();
            Check.That(anotherDurationWithSameValue.Equals(20)).IsFalse();
            Check.That(anotherDurationWithSameValue.Equals((object)firstDuration)).IsTrue();
        }
Exemple #29
0
 public bool Equals(Song song)
 {
     if (Path.Equals(song.Path) &&
         Title.Equals(song.Title) &&
         Artist.Equals(song.Artist) &&
         Album.Equals(song.Album) &&
         Duration.Equals(song.Duration))
     {
         return(true);
     }
     return(false);
 }
        public override bool Equals(object obj)
        {
            if (obj == null || obj.GetType() != this.GetType())
            {
                return(false);
            }
            Operation operationTmp = (Operation)obj;

            return(Id.Equals(operationTmp.Id) &&
                   Description.Equals(operationTmp.Description) &&
                   Duration.Equals(operationTmp.Duration) &&
                   Tool.Equals(operationTmp.Tool));
        }
Exemple #31
0
 public bool Equals(TimerMessage?other)
 {
     if (ReferenceEquals(null, other))
     {
         return(false);
     }
     if (ReferenceEquals(this, other))
     {
         return(true);
     }
     return(_id.Equals(other._id) && Text == other.Text && Duration.Equals(other.Duration) &&
            Expiration.Equals(other.Expiration) && ShowFullScreen == other.ShowFullScreen);
 }
Exemple #32
0
        public void TestDurationClass()
        {
            var test = new Duration(200, TimeUnit.Minutes);

            Assert.AreEqual(200, test.RawDuration);

            Assert.AreEqual(TimeUnit.Minutes, test.Unit);

            Assert.AreEqual("200 Minutes", test.ToString());

            Assert.IsTrue(test > new Duration(100, TimeUnit.Seconds));
            Assert.IsTrue(test < new Duration(100, TimeUnit.Hours));

            var altDuration = new Duration(200, TimeUnit.Minutes);

            // test objects override
            Assert.AreEqual(altDuration.GetHashCode(), test.GetHashCode());
            Assert.AreEqual(altDuration, test);
            Assert.IsTrue(altDuration.Equals(test));
            Assert.IsTrue(altDuration == test);
            Assert.IsFalse(altDuration.Equals(null));
            Assert.IsFalse(altDuration.Equals(20));
            Assert.IsTrue(altDuration.Equals((object)test));
        }
Exemple #33
0
 public static bool Equals(Duration t1, Duration t2)
 {
     return t1.Equals(t2);
 }
Exemple #34
0
        //=====================================================================

        /// <summary>
        /// Returns a value indicating whether two specified instances of <c>Duration</c> are equal
        /// </summary>
        /// <param name="d1">The first duration to compare</param>
        /// <param name="d2">The second duration to compare</param>
        /// <returns>Returns true if the durations are equal, false if they are not</returns>
        public static bool Equals(Duration d1, Duration d2)
        {
            if((object)d1 == null && (object)d2 == null)
                return true;

            if((object)d1 == null)
                return false;

            return d1.Equals(d2);
        }