public void Comparison()
        {
            var firstDate = new Date(2011, 1, 1);
            var sameAsFirstDate = new Date(2011, 1, 1);
            var laterDate = new Date(2011, 1, 2);

            Expect(firstDate < laterDate);
            Expect(laterDate < firstDate, Is.False);

            Expect(firstDate > laterDate, Is.False);
            Expect(laterDate > firstDate);

            Expect(firstDate <= laterDate);
            Expect(laterDate <= firstDate, Is.False);

            Expect(firstDate >= laterDate, Is.False);
            Expect(laterDate >= firstDate);

            Expect(firstDate <= sameAsFirstDate);
            Expect(firstDate >= sameAsFirstDate);
            Expect(firstDate < sameAsFirstDate, Is.False);
            Expect(firstDate > sameAsFirstDate, Is.False);

            Expect(firstDate, Is.EqualTo(sameAsFirstDate));
            Expect(firstDate.Equals(sameAsFirstDate));
        }

 public static int GetMonthlyPrintNumber(Date date, int refNumber, Date refDate, Month noPrintMonths, Dictionary<int, int> noPrintDates, Dictionary<int, int> noPrintNumbers)
 {
     int no = refNumber;
     Date date2 = refDate;
     while (date > date2)
     {
         date2 = date2.AddMonths(1);
         Month month = zdate.GetMonth(date2.Month);
         if ((noPrintMonths & month) != month && !noPrintDates.ContainsKey(date2.AbsoluteDay))
         {
             do
             {
                 no++;
             } while (noPrintNumbers.ContainsKey(no));
         }
     }
     while (date < date2)
     {
         Month month = zdate.GetMonth(date2.Month);
         if ((noPrintMonths & month) != month && !noPrintDates.ContainsKey(date2.AbsoluteDay))
         {
             do
             {
                 no--;
             } while (noPrintNumbers.ContainsKey(no));
         }
         date2 = date2.AddMonths(-1);
     }
     return no;
 }

 public Construction(BuildingType type, Settlement location, Date today)
 {
     _type = type;
     _location = location;
     _startDate = today;
     //_resourceRequirements = _type.RequirementsFor(location);
 }

        /// <summary>
        /// Contains 目标时刻是否在时间范围内
        /// </summary>       
        public bool Contains(Date target)
        {
            bool bStart = this._start.CompareTo(target) <= 0;
            bool bEnd = this._end.CompareTo(target) >= 0;

            return bStart && bEnd;
        }

 static void Main(string[] args)
 {
     Date aDate = new Date();
     Date anotherDate = new Date(2003, 11, 5);
     Console.WriteLine("aDate:\n" + aDate);
     Console.WriteLine("anotherDate:\n" + anotherDate);
 }

		public virtual void EmbeddingOfInstanceOfCustomValueTypeWithFieldsIsCorrect()
		{
			// Arrange
			var date = new Date(2015, 12, 29);
			const string updateCode = "date.Day += 2;";

			const string input1 = "date.Year";
			const int targetOutput1 = 2015;

			const string input2 = "date.Month";
			const int targetOutput2 = 12;

			const string input3 = "date.Day";
			const int targetOutput3 = 31;

			// Act
			int output1;
			int output2;
			int output3;

			using (var jsEngine = CreateJsEngine())
			{
				jsEngine.EmbedHostObject("date", date);
				jsEngine.Execute(updateCode);

				output1 = jsEngine.Evaluate<int>(input1);
				output2 = jsEngine.Evaluate<int>(input2);
				output3 = jsEngine.Evaluate<int>(input3);
			}

			// Assert
			Assert.AreEqual(targetOutput1, output1);
			Assert.AreEqual(targetOutput2, output2);
			Assert.AreEqual(targetOutput3, output3);
		}

        public void ctor_DateTime_whenLocalTime()
        {
            Date expected = "2012-03-26";
            var actual = new Date(new DateTime(2012, 03, 25, 2, 1, 0, DateTimeKind.Local)).ToDateTime().AddDays(1).ToDate();

            Assert.Equal(expected, actual);
        }

 /// <summary>
 /// If the book is returned on or before the expected return date, no fine will be charged, in other words fine is 0. 
 /// If the book is returned in the same month as the expected return date, Fine = 15 Hackos × Number of late days
 /// If the book is not returned in the same month but in the same year as the expected return date, Fine = 500 Hackos × Number of late months
 /// If the book is not returned in the same year, the fine is fixed at 10000 Hackos.
 /// </summary>
 static int CalculateFee(Date returnDate, Date expectedDate)
 {
     if (returnDate.year > expectedDate.year) { return 10000; }
     else if ((returnDate.year == expectedDate.year) && returnDate.month > expectedDate.month) { return (returnDate.month - expectedDate.month) * 500; }
     else if ((returnDate.year == expectedDate.year && returnDate.month == expectedDate.month) && returnDate.day > expectedDate.day) { return (returnDate.day - expectedDate.day) * 15; }
     else { return 0; } // returned early
 }

 public void CanConstructFromDateTime()
 {
   Date d1 = new Date(new DateTime(2001, 2, 3, 4, 5, 6, 7).AddTicks(8));
   Date d2 = new Date(2001, 2, 3);
   Assert.AreEqual(d1, d2);
   Assert.IsTrue(d1.Equals(d2));
 }

        public void AddMinutes_2280_AreEqual()
        {
            var act = TestStruct.AddMinutes(2 * 24 * 60);
            var exp = new Date(1970, 02, 16);

            Assert.AreEqual(exp, act);
        }

        public void AddMonths_12_AreEqual()
        {
            var act = TestStruct.AddMonths(12);
            var exp = new Date(1971, 02, 14);

            Assert.AreEqual(exp, act);
        }

        public void AddMilliseconds_Arround3Days_AreEqual()
        {
            var act = TestStruct.AddMilliseconds(3 * 24 * 60 * 60 * 1003);
            var exp = new Date(1970, 02, 17);

            Assert.AreEqual(exp, act);
        }

        public void AddHours_41_AreEqual()
        {
            var act = TestStruct.AddHours(41);
            var exp = new Date(1970, 02, 15);

            Assert.AreEqual(exp, act);
        }

        public void Equals_ConstructorDateWithTime_DoesNotCompareTime()
        {
            var dayWithTime = new Date(new DateTime(2011, 1, 1, 1, 0, 0));
            var sameDayWithOutTime = new Date(new DateTime(2011, 1, 1));

            Expect(dayWithTime, Is.EqualTo(sameDayWithOutTime));
        }

        public ViewMoverKenBurnsStyle(CameraParameters from, CameraParameters to, double time, Date fromDateTime, Date toDateTime, InterpolationType type)
        {
            InterpolationType = type;

            if (Math.Abs(from.Lng - to.Lng) > 180)
            {
                if (from.Lng > to.Lng)
                {
                    from.Lng -= 360;
                }
                else
                {
                    from.Lng += 360;
                }
            }

            this.fromDateTime = fromDateTime;
            this.toDateTime = toDateTime;

            dateTimeSpan = toDateTime - fromDateTime;

            this.from = from.Copy();
            this.to = to.Copy();
            fromTime = Date.Now;
            toTargetTime = time;
        }

 public void ToDateRemovesAllTimePortion()
 {
   Date d1 = new DateTime(2001, 2, 3, 4, 5, 6, 7).AddTicks(8).ToDate();
   Date d2 = new Date(2001, 2, 3);
   Assert.AreEqual(d1, d2);
   Assert.IsTrue(d1.Equals(d2));
 }

		public string ExportRaw(ClientConfiguration clientConfiguration, Date from, Date to, string[] events = null)
		{
			try
			{
				var uri = MixPanelEndpointConfiguration.RawExportUrl;

				var parameterDictionary = new Dictionary<string, string>();

				parameterDictionary.Add(FromDateParamName, from.ToString());
				parameterDictionary.Add(ToDateParamName, to.ToString());
				if (events != null
				    && events.Any())
					parameterDictionary.Add(EventParamName, StringifyEvents(events));

				var callingUri =
					new Uri(uri.ToString() + "?" + string.Join("&", parameterDictionary.Select(x => x.Key + "=" + x.Value)));

				var webClientResponse = _webClient.QueryUri(callingUri,
				                                            new BasicAuthentication { UserName = clientConfiguration.Secret });

				return webClientResponse;
			}
			catch (WebException ex)
			{
				TryHandleWebException(ex);
				throw new MixPanelClientException(ex);
			}
			catch (Exception ex)
			{
				throw new MixPanelClientException(ex);
			}
		}

 public static int GetDailyPrintNumber(Date date, int refNumber, Date refDate, SpecialDay noPrintDays, Dictionary<int, int> noPrintDates, Dictionary<int, int> noPrintNumbers)
 {
     int no = refNumber;
     Date date2 = refDate;
     while (date > date2)
     {
         date2 = date2.AddDays(1);
         if (!noPrintDates.ContainsKey(date2.AbsoluteDay) && !SpecialDayTools.IsSpecialDay(noPrintDays, date2))
         {
             do
             {
                 no++;
             } while (noPrintNumbers.ContainsKey(no));
         }
     }
     while (date < date2)
     {
         if (!noPrintDates.ContainsKey(date2.AbsoluteDay) && !SpecialDayTools.IsSpecialDay(noPrintDays, date2))
         {
             do
             {
                 no--;
             } while (noPrintNumbers.ContainsKey(no));
         }
         date2 = date2.AddDays(-1);
     }
     return no;
 }

        public void MultipleTypeCustomInstanceAnnotationsOnErrorShouldRoundtrip()
        {
            var originalInt = new KeyValuePair<string, ODataValue>("int.error", new ODataPrimitiveValue(1));
            var originalDouble = new KeyValuePair<string, ODataValue>("double.error", new ODataPrimitiveValue(double.NaN));
            DateTimeOffset dateTimeOffset = new DateTimeOffset(2012, 10, 10, 12, 12, 59, new TimeSpan());
            var originalDateTimeOffset = new KeyValuePair<string, ODataValue>("DateTimeOffset.error", new ODataPrimitiveValue(dateTimeOffset));
            Date date = new Date(2014, 12, 12);
            var originalDate = new KeyValuePair<string, ODataValue>("Date.error", new ODataPrimitiveValue(date));
            TimeOfDay time = new TimeOfDay(10, 12, 3, 9);
            var originaltime = new KeyValuePair<string, ODataValue>("TimeOfDay.error", new ODataPrimitiveValue(time));
            TimeSpan timeSpan = new TimeSpan(12345);
            var originalTimeSpan = new KeyValuePair<string, ODataValue>("TimeSpan.error", new ODataPrimitiveValue(timeSpan));
            GeographyPoint geographyPoint = GeographyPoint.Create(32.0, -100.0);
            var originalGeography = new KeyValuePair<string, ODataValue>("Geography.error", new ODataPrimitiveValue(geographyPoint));
            var originalNull = new KeyValuePair<string, ODataValue>("null.error", new ODataNullValue());

            var complexValue = new ODataComplexValue
            {
                TypeName = "ns.ErrorDetails",
                Properties = new[] { new ODataProperty { Name = "ErrorDetailName", Value = "inner property value" } }
            };
            var originalComplex = new KeyValuePair<string, ODataValue>("sample.error", complexValue);

            var error = this.WriteThenReadErrorWithInstanceAnnotation(originalInt, originalDouble, originalDate, originalDateTimeOffset, originaltime, originalTimeSpan, originalGeography, originalNull, originalComplex);

            var annotation = RunBasicVerificationAndGetAnnotationValue("int.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(1);

            annotation = RunBasicVerificationAndGetAnnotationValue("double.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(double.NaN);

            annotation = RunBasicVerificationAndGetAnnotationValue("Date.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(date);

            annotation = RunBasicVerificationAndGetAnnotationValue("DateTimeOffset.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(dateTimeOffset);

            annotation = RunBasicVerificationAndGetAnnotationValue("TimeOfDay.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(time);

            annotation = RunBasicVerificationAndGetAnnotationValue("TimeSpan.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(timeSpan);

            annotation = RunBasicVerificationAndGetAnnotationValue("Geography.error", error);
            annotation.Should().BeOfType<ODataPrimitiveValue>();
            annotation.As<ODataPrimitiveValue>().Value.Should().Be(geographyPoint);

            annotation = RunBasicVerificationAndGetAnnotationValue("null.error", error);
            annotation.Should().BeOfType<ODataNullValue>();

            annotation = RunBasicVerificationAndGetAnnotationValue("sample.error", error);
            annotation.Should().BeOfType<ODataComplexValue>();
            annotation.As<ODataComplexValue>().Properties.First().Value.Should().Be("inner property value");
        }

 public BlendState()
 {
     switchedTime = new Date(1990, 0, 0, 0, 0, 0, 0);
     state = false;
     targetState = state;
     this.delayTime = 1000;
 }