public void MinCalendarYear_EqualsYear1() { var minCalYear = CalendarYear.MinCalendarYear; var year1 = new CalendarYear(1); Assert.AreEqual(year1, minCalYear); }
public void End_ShouldEqualDateTimeForStartOfNextYear(int yearNum) { var calendarYear = new CalendarYear(yearNum); var expectedEnd = new DateTime(yearNum + 1, 1, 1); Assert.AreEqual(expectedEnd, calendarYear.End); }
private static CalendarYear TweakYear(this CalendarYear calendarYear) { var tweakedYear = A.Dummy <PositiveInteger>().ThatIs(y => y != calendarYear.Year && y <= 9999); var result = new CalendarYear(tweakedYear); return(result); }
private static void OffsetOperators() { #region offset_operators var calYear19 = new CalendarYear(2019); CalendarYear calYear22 = calYear19 + 3; Console.WriteLine(calYear22); int yearsDifference = calYear22 - calYear19; Console.WriteLine(yearsDifference); // The increment ++, and decrement --, operators can also be used var halfHour = new HalfHour(2019, 8, 30, 22, 0); Console.WriteLine(); Console.WriteLine("Incrementing Half Hour"); Console.WriteLine(halfHour); halfHour++; Console.WriteLine(halfHour); halfHour++; Console.WriteLine(halfHour); Console.WriteLine(); Console.WriteLine("Decrementing Half Hour"); halfHour--; Console.WriteLine(halfHour); halfHour--; Console.WriteLine(halfHour); halfHour--; Console.WriteLine(halfHour); Console.WriteLine(); #endregion offset_operators }
public void MaxCalendarYear_EqualsYear9998() { var maxCalYear = CalendarYear.MaxCalendarYear; var year9998 = new CalendarYear(9998); Assert.AreEqual(year9998, maxCalYear); }
public void GetHashCode_OnTwoDifferentInstances_ReturnDifferentValue(int yearNum1, int yearNum2) { var calYear1 = new CalendarYear(yearNum1); var calYear2 = new CalendarYear(yearNum2); Assert.AreNotEqual(calYear1.GetHashCode(), calYear2.GetHashCode()); }
public void IComparableCompareTo_WithParameterEqualToNull_Returns1(int yearNum) { IComparable calYear = new CalendarYear(yearNum); var comp = calYear.CompareTo(null); Assert.AreEqual(1, comp); }
public void LessThanOrEqualToOperator_WithLeftLaterThanRight_ReturnsFalse(int leftYearNum, int rightYearNum) { var calYear1 = new CalendarYear(leftYearNum); var calYear2 = new CalendarYear(rightYearNum); Assert.IsFalse(calYear1 <= calYear2); }
public void Start_ShouldEqualDateTimeForStartOfYear(int yearNum) { var calendarYear = new CalendarYear(yearNum); var expectedStart = new DateTime(yearNum, 1, 1); Assert.AreEqual(expectedStart, calendarYear.Start); }
public void LessThanOperator_WithLeftEarlierThanRight_ReturnsTrue(int leftYearNum, int rightYearNum) { var calYear1 = new CalendarYear(leftYearNum); var calYear2 = new CalendarYear(rightYearNum); Assert.IsTrue(calYear1 < calYear2); }
public void GreaterThanOrEqualToOperator_WithLeftLaterThanOrEqualToRight_ReturnsTrue(int leftYearNum, int rightYearNum) { var calYear1 = new CalendarYear(leftYearNum); var calYear2 = new CalendarYear(rightYearNum); Assert.IsTrue(calYear1 >= calYear2); }
public void InequalityOperator_WithTwoIdenticalInstances_ReturnsFalse(int yearNum) { var calYear1 = new CalendarYear(yearNum); var calYear2 = new CalendarYear(yearNum); Assert.IsFalse(calYear1 != calYear2); }
public void InequalityOperator_WithTwoDifferentInstances_ReturnsTrue(int leftYearNum, int rightYearNum) { var calYear1 = new CalendarYear(leftYearNum); var calYear2 = new CalendarYear(rightYearNum); Assert.IsTrue(calYear1 != calYear2); }
public void DefaultConstructor_ReturnsInstanceEqualToYear1() { var calYear = new CalendarYear(); var year1 = new CalendarYear(1); Assert.AreEqual(year1, calYear); }
public void GetHashCode_OnTwoIdenticalInstances_ReturnSameValue(int yearNum) { var calYear1 = new CalendarYear(yearNum); var calYear2 = new CalendarYear(yearNum); Assert.AreEqual(calYear1.GetHashCode(), calYear2.GetHashCode()); }
public void IComparableCompareTo_WithParameterLaterThanInstance_ReturnsNegativeNumber(int yearNumInstance, int yearNumParameter) { IComparable calYear1 = new CalendarYear(yearNumInstance); object calYear2 = new CalendarYear(yearNumParameter); var comp = calYear1.CompareTo(calYear2); Assert.That(comp, Is.LessThan(0)); }
public void IComparableCompareTo_WithParameterNotOfCalendarYearType_ThrowsArgumentException(int yearNum) { IComparable calYear = new CalendarYear(yearNum); object obj = new object(); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Assert.Throws <ArgumentException>(() => calYear.CompareTo(obj)); }
public void IComparableCompareTo_WithParameterIdenticalToInstance_ReturnsZero(int yearNum) { IComparable calYear1 = new CalendarYear(yearNum); object calYear2 = new CalendarYear(yearNum); var comp = calYear1.CompareTo(calYear2); Assert.AreEqual(0, comp); }
public void CompareTo_WithParameterEarlierThanInstance_ReturnsPositiveNumber(int yearNumInstance, int yearNumParameter) { var calYear1 = new CalendarYear(yearNumInstance); var calYear2 = new CalendarYear(yearNumParameter); var comp = calYear1.CompareTo(calYear2); Assert.That(comp, Is.GreaterThan(0)); }
public void ObjectEquals_WithParameterNotOfTypeCalendarYear_ReturnsFalse(int yearNum) { object calYear = new CalendarYear(yearNum); object obj = new object(); var equals = calYear.Equals(obj); Assert.IsFalse(equals); }
public void ObjectEquals_WithTwoDifferentInstances_ReturnsFalse(int yearNum1, int yearNum2) { object calYear1 = new CalendarYear(yearNum1); object calYear2 = new CalendarYear(yearNum2); var equals = calYear1.Equals(calYear2); Assert.IsFalse(equals); }
public void ObjectEquals_WithTwoIdenticalInstances_ReturnsTrue(int yearNum) { object calYear1 = new CalendarYear(yearNum); object calYear2 = new CalendarYear(yearNum); var equals = calYear1.Equals(calYear2); Assert.IsTrue(equals); }
private static CalendarYear TweakBy( this CalendarYear calendarYear, int amount) { var result = new CalendarYear(calendarYear.Year + amount); return(result); }
public void MinusMinusOperator_EqualsPreviousCalendarYear(int yearNum) { var calYear = new CalendarYear(yearNum); var previousCalYear = new CalendarYear(yearNum - 1); calYear--; Assert.AreEqual(previousCalYear, calYear); }
public void FromDateTime_ReturnsCalendarYearForYearOfParameterYear( [ValueSource(nameof(DateTimesForFromDateTimeTest))] DateTime dateTime) { var calYear = CalendarYear.FromDateTime(dateTime); var expectedCalYear = new CalendarYear(dateTime.Year); Assert.AreEqual(expectedCalYear, calYear); }
public void PlusPlusOperator_EqualsNextCalendarYear(int yearNum) { var calYear = new CalendarYear(yearNum); var nextCalYear = new CalendarYear(yearNum + 1); calYear++; Assert.AreEqual(nextCalYear, calYear); }
public void MinusOperatorIntParameter_ReturnsYearMinusYearsSubtracted(int yearNum, int numTimePeriods) { var calYear = new CalendarYear(yearNum); var calYearAfterSubtraction = calYear - numTimePeriods; var expectedYearAfterSubtraction = new CalendarYear(yearNum - numTimePeriods); Assert.AreEqual(expectedYearAfterSubtraction, calYearAfterSubtraction); }
public void MinusOperatorCalYearParameter_ReturnsDifferenceInYearNumbers(int yearNum1, int yearNum2) { var calYear1 = new CalendarYear(yearNum1); var calYear2 = new CalendarYear(yearNum2); var yearDifference = calYear1 - calYear2; var expectedYearDifference = yearNum1 - yearNum2; Assert.AreEqual(expectedYearDifference, yearDifference); }
public void OffsetFrom_ReturnsDifferenceInYears(int yearNum1, int yearNum2) { var calYear1 = new CalendarYear(yearNum1); var calYear2 = new CalendarYear(yearNum2); var diff = calYear1.OffsetFrom(calYear2); var expectedDiff = yearNum1 - yearNum2; Assert.AreEqual(expectedDiff, diff); }
public void AdditionOperator_ReturnsYearPlusNumYearsAdded(int yearNum, int numTimePeriods) { var calYear = new CalendarYear(yearNum); var calYearAfterAddition = calYear + numTimePeriods; int expectedYearNumAfterAddition = yearNum + numTimePeriods; var expectedYearAfterAddition = new CalendarYear(expectedYearNumAfterAddition); Assert.AreEqual(expectedYearAfterAddition, calYearAfterAddition); }
public static CalendarYear CreateCalendarYear() { var today = DateTime.Today; var yearStart = new DateTime(today.Year, 1, 1); var year = new CalendarYear(today.Year); for (int i = 0; i < 12; i++) { year.Blocks.Add(CreateBlock(yearStart.AddMonths(i), yearStart.AddMonths(i + 1).AddDays(-1))); } AssignBaseObjectProperties(year); return year; }
public void Schedule() { var assigner = MockRepository.GenerateMock<ICalendarAssigner>(); var assignmentResult = new CalendarAssignmentResult(); var calendar = new CalendarYear(2013){Id = 1}; var residents = new List<Resident>(); assigner.Stub(a => a.Assign(calendar, residents)).Return(assignmentResult); var result = new Scheduler(assigner).Schedule(calendar, residents); Assert.AreEqual(assignmentResult, result.AssignmentResult); }
public void CalendarYear_Set_When_BlockAdded() { var calendarYear = new CalendarYear(DateTime.Today.Year); var block1 = new Block(); calendarYear.Blocks.Add(block1); Assert.AreEqual(calendarYear, block1.CalendarYear); var block2 = new Block(); var block3 = new Block(); calendarYear.Blocks.AddRange(new List<Block>{block2,block3}); Assert.AreEqual(calendarYear, block2.CalendarYear); Assert.AreEqual(calendarYear, block3.CalendarYear); }
public void All_Blocks_InValid() { var mockery = new MockRepository(); var block = mockery.PartialMock<Block>(); using (mockery.Record()) { Expect.Call(block.IsValid).Return(false); } using (mockery.Playback()) { var year = new CalendarYear(2011); year.Blocks.Add(block); Assert.IsFalse(year.IsValid); } }
public void All_Blocks_Valid() { var mockery = new MockRepository(); var block = mockery.PartialMock<Block>(); var validator = mockery.DynamicMock<ICollectionValidator<Block>>(); using (mockery.Record()) { Expect.Call(block.IsValid).Return(true); SetupResult.For(validator.Validate(null)).IgnoreArguments().Return(true); } using (mockery.Playback()) { var year = new CalendarYear(2011, validator); year.Blocks.Add(block); Assert.IsTrue(year.IsValid); } }
public void Assign() { var assigner = MockRepository.GenerateMock<IBlockAssigner>(); var calendar = new CalendarYear(2013) { Id = 1 }; var blocks = new List<Block> {new Block(), new Block()}; blocks.ForEach(calendar.Blocks.Add); var residents = new List<Resident> { new Resident() }; var residents2 = new List<Resident> { new Resident(), new Resident() }; var assignmentResult = new BlockAssignmentResult(residents2); assigner.Stub(a => a.Assign(blocks, residents)).Return(assignmentResult); var result = new CalendarAssigner(assigner).Assign(calendar, residents); Assert.AreEqual(residents2, result.Residents); }
static CalendarYear CreateCalendar() { var calendar = new CalendarYear(2013); calendar.Blocks.Add(CreateBlock(new DateTime(calendar.Year, 1, 1), new DateTime(calendar.Year, 1, 15))); return calendar; }
public CalendarAssignmentResult Assign(CalendarYear calendar, IEnumerable<Resident> residents) { return new CalendarAssignmentResult(assigner.Assign(calendar.Blocks, residents).Residents); }