private static void DoTest(DateTime dt, DateTimeKind inKind, DateTimeKind outKind)
		{
			Assert.Equal(inKind, dt.Kind);

			using (var documentStore = new EmbeddableDocumentStore { RunInMemory = true })
			{
				documentStore.Initialize();

				using (var session = documentStore.OpenSession())
				{
					session.Store(new Foo { Id = "foos/1", DateTime = dt });
					session.SaveChanges();
				}

				using (var session = documentStore.OpenSession())
				{
					var foo = session.Query<Foo>()
									 .Customize(x => x.WaitForNonStaleResults())
									 .FirstOrDefault(x => x.DateTime == dt);

					WaitForUserToContinueTheTest(documentStore);

					Assert.Equal(dt, foo.DateTime);
					Assert.Equal(outKind, foo.DateTime.Kind);
				}
			}
		}

 public static DateTime GetDateInUserTimeZone(DateTime sourceDate, DateTimeKind sourceDateTimeKind, User user)
 {
     sourceDate = DateTime.SpecifyKind(sourceDate, sourceDateTimeKind);
     //get the timezone of mentioned user
     var userTimezoneId = user.GetPropertyValueAs<string>(PropertyNames.DefaultTimeZoneId);
     if (string.IsNullOrEmpty(userTimezoneId))
     {
         //get default timezone
         var generalSettings = mobSocialEngine.ActiveEngine.Resolve<GeneralSettings>();
         userTimezoneId = generalSettings.DefaultTimeZoneId;
     }
     //let's find the timezone
     TimeZoneInfo timeZoneInfo;
     try
     {
         timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(userTimezoneId);
     }
     catch
     {
         //in case of error let's default to local timezone
         timeZoneInfo = TimeZoneInfo.Local;
     }
     //get the timezone
     return GetDateInTimeZone(sourceDate, timeZoneInfo);
 }

        public DateParser(string format, DateTimeKind kind)
        {
            switch (kind)
            {
                case DateTimeKind.Local:
                    _style = DateTimeStyles.AssumeLocal;
                    break;

                case DateTimeKind.Utc:
                    _style = DateTimeStyles.AssumeUniversal;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("kind");
            }

            switch (format)
            {
                case "ABSOLUTE":
                    break;

                case "ISO8601":
                    break;

                case "DATE":
                    break;
            }
        }

        /// <summary>
        /// Gets the Minimum value for a DateTime specifying kind.
        /// </summary>
        /// <param name="kind">DateTimeKind to use.</param>
        /// <returns>DateTime of specified kind.</returns>
        public static DateTime GetMinValue(DateTimeKind kind)
        {
            if (kind == DateTimeKind.Unspecified)
                return new DateTime(DateTime.MinValue.Ticks, DateTimeKind.Utc);

            return new DateTime(DateTime.MinValue.Ticks, kind);
        }

        /// <summary>
        /// 現在のインスタンスと比較します。
        /// </summary>
        /// <param name="self">自分自身</param>
        /// <param name="value">比較する値</param>
        /// <param name="compareKind">比較する時間の種別</param>
        /// <returns>比較結果(true:一致, false:不一致)</returns>
        public static bool Compare(this DateTime self, DateTime value, DateTimeKind compareKind)
        {
            var ts = self - value;
            double total = 0D;
            double sub = 1.0D;

            switch (compareKind)
            {
                case DateTimeKind.Year:
                    total = self.Year - value.Year;
                    break;
                case DateTimeKind.Month:
                    sub = 30.0D;
                    total = ts.TotalDays;
                    break;
                case DateTimeKind.Day:
                    total = ts.TotalDays;
                    break;
                case DateTimeKind.Hour:
                    total = ts.TotalHours;
                    break;
                case DateTimeKind.Minute:
                    total = ts.TotalMinutes;
                    break;
                case DateTimeKind.Second:
                    total = ts.TotalSeconds;
                    break;
                case DateTimeKind.Milliseconds:
                    total = ts.TotalMilliseconds;
                    break;
            }

            return Math.Abs(total) < sub;
        }

 public void SetPosition(DateTime when, DateTimeKind whenKind, double latitudeDegrees, double longitudeDegrees)
 {
   IntPtr pSun = NonConstPointer();
   UnsafeNativeMethods.Rdk_Sun_SetLatitudeLongitude(pSun, latitudeDegrees, longitudeDegrees);
   bool local = whenKind != DateTimeKind.Utc;
   UnsafeNativeMethods.Rdk_Sun_SetDateTime(pSun, local, when.Year, when.Month, when.Day, when.Hour, when.Minute, when.Second);
 }

 /// <summary>
 /// Initializes a new instance of the DateTimeSerializationOptions class.
 /// </summary>
 /// <param name="kind">The DateTimeKind (Local, Unspecified or Utc).</param>
 /// <param name="representation">The external representation.</param>
 public DateTimeSerializationOptions(
     DateTimeKind kind,
     BsonType representation
 ) {
     this.kind = kind;
     this.representation = representation;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="UserDataRule" /> class.
 /// </summary>
 /// <param name="columnName">Name of the column.</param>
 /// <param name="kind">The kind.</param>
 /// <param name="appliesWhen">The rule can be applied to insert, update, and/or soft delete operations.</param>
 /// <exception cref="ArgumentOutOfRangeException">appliesWhen;appliesWhen may only be a combination of Insert, Update, or Delete</exception>
 /// <remarks>
 /// This will have no effect on hard deletes.
 /// </remarks>
 public DateTimeRule(string columnName, DateTimeKind kind, OperationTypes appliesWhen) : base(columnName, appliesWhen)
 {
     if (appliesWhen.HasFlag(OperationTypes.Select))
         throw new ArgumentOutOfRangeException("appliesWhen", appliesWhen, "appliesWhen may only be a combination of Insert, Update, or Delete");
     if (kind == DateTimeKind.Unspecified)
         throw new ArgumentOutOfRangeException("kind");
     Kind = kind;
 }

 public static SharpMapillaryInfo LoadJPEG(this SharpMapillaryInfo           MapillaryInfo,
                                           String                            JPEGFile,
                                           DateTimeKind                      DateTimeType         = DateTimeKind.Utc,
                                           Int32?                            TimeOffset           = null,
                                           Func<String, DateTime, DateTime>  OnDupliateTimestamp  = null)
 {
     return LoadJPEG(JPEGFile, ref MapillaryInfo, DateTimeType, TimeOffset, OnDupliateTimestamp);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="BsonReader"/> class.
 /// </summary>
 /// <param name="stream">The stream.</param>
 /// <param name="readRootValueAsArray">if set to <c>true</c> the root object will be read as a JSON array.</param>
 /// <param name="dateTimeKindHandling">The <see cref="DateTimeKind" /> used when reading <see cref="DateTime"/> values from BSON.</param>
 public BsonReader(Stream stream, bool readRootValueAsArray, DateTimeKind dateTimeKindHandling)
 {
     ValidationUtils.ArgumentNotNull(stream, "stream");
     _reader = new BinaryReader(stream);
     _stack = new List<ContainerContext>();
     _readRootValueAsArray = readRootValueAsArray;
     _dateTimeKindHandling = dateTimeKindHandling;
 }

 public DateTimeDataType(int id, string name, string alias, DataType basic, DataType parent, bool editable,
     DateTimeKind part, DateTime minValue, DateTime maxValue, bool nullable)
     : base(id, name, alias, basic, parent, editable, nullable)
 {
     this.part = part;
     this.minValue = minValue;
     this.maxValue = maxValue;
 }

        /// <summary>
        ///     Returns DateTime created from an integer in the YYYYMMDD, YYYYMMDDHHmmss, or YYYYMMDDHHmmssFFF format.
        /// </summary>
        /// <param name="sortableDateTime"></param>
        /// <param name="dtKind"></param>
        /// <returns></returns>
        public static DateTime? FromSortableIntDateTime(this string sortableDateTime, DateTimeKind dtKind = DateTimeKind.Unspecified)
        {
            long? sortableVal = sortableDateTime.ParseLong();
            if(sortableVal == null)
                return null;

            return sortableVal.Value.FromSortableIntDateTime(dtKind);
        }

        /// <summary>
        /// Obtient une date dans le kind spécifié en fonction des paramètres spécifiés
        /// </summary>
        /// <param name="rule"><see cref="RuleDate"/> décrivant la date</param>
        /// <param name="year">Année de la date</param>
        /// <param name="gmtOffset">Offset gmt dans lequel est exprimé la date</param>
        /// <param name="stdOffset">Offset standard dans lequel est exprimé la date</param>
        /// <param name="dateTimeKind"><see cref="DateTimeKind"/> dans lequel exprimer la date</param>
        /// <returns><see cref="DateTime"/> du kind spécifié correspondant aux paramètres spécifiés</returns>
        public static DateTime GetDateTime(RuleDate rule, int year, TimeSpan gmtOffset, TimeSpan stdOffset, DateTimeKind dateTimeKind)
        {
            if (dateTimeKind == DateTimeKind.Unspecified) throw new ArgumentException("Unspecified date time kind", "dateTimeKind");

            if (dateTimeKind == DateTimeKind.Local)
                return GetWallClockTime(rule, year, gmtOffset, stdOffset);
            return GetUTCTime(rule, year, gmtOffset, stdOffset);
        }

        public __DateTime()
        {
            this.Kind = DateTimeKind.Local;
            // fix for default(DateTime).ToString
            // X:\jsc.svn\examples\javascript\Test\TestDateTime\TestDateTime\Program.cs
            this.InternalValue = new IDate();

        }

 public DateTime GetCurrentTime(DateTimeKind dateTimeKind)
 {
     switch (dateTimeKind)
     {
         case DateTimeKind.Local: return DateTime.Now.ToLocalTime();
         case DateTimeKind.Utc: return DateTime.Now.ToUniversalTime();
         default: return DateTime.Now;
     }
 }

    public static DateTime GetContextNow( DateTimeKind kind )
    {
      if( kind == DateTimeKind.Unspecified )
        return DateTime.SpecifyKind( DateTime.Now, DateTimeKind.Unspecified );

      return ( kind == DateTimeKind.Utc )
        ? DateTime.UtcNow
        : DateTime.Now;
    }

        public static DateTime? SpecifyKindIfUnspecified(DateTime? dateTime, DateTimeKind kind)
        {
            if (dateTime == null)
            {
                return null;
            }

            return dateTime.Value.Kind == DateTimeKind.Unspecified ? DateTime.SpecifyKind(dateTime.Value, kind) : dateTime;
        }

        public DateTimeWithZone(DateTime dateTime, TimeZoneInfo timeZone, DateTimeKind kind = DateTimeKind.Utc)
        {
            dateTime = DateTime.SpecifyKind(dateTime, kind);

            utcDateTime = dateTime.Kind != DateTimeKind.Utc
                            ? TimeZoneInfo.ConvertTimeToUtc(dateTime, timeZone)
                            : dateTime;

            this.timeZone = timeZone;
        }

 /// <summary>
 /// DateTime을 Unix timestamp로 반환합니다.
 /// </summary>
 /// <param name="date">변환할 DateTime</param>
 /// <param name="includeMilliseconds">밀리초 단위인지 여부</param>
 /// <param name="kind">DateTime의 종류</param>
 /// <returns>변환된 Unix timestamp</returns>
 public static long ToUnixTime(this DateTime date, bool includeMilliseconds = true, DateTimeKind kind = DateTimeKind.Utc)
 {
     var epoch = new DateTime(1970, 1, 1, 0, 0, 0, kind);
     var diff = includeMilliseconds ? (date - epoch).TotalMilliseconds : (date - epoch).TotalSeconds;
     #if DNXCORE50
     return (long)diff;
     #else
     return (long)Math.Floor(diff);
     #endif
 }

 /// <summary>
 /// Converts a DateTime to local time (with special handling for MinValue and MaxValue).
 /// </summary>
 /// <param name="dateTime">A DateTime.</param>
 /// <param name="kind">A DateTimeKind.</param>
 /// <returns>The DateTime in local time.</returns>
 public static DateTime ToLocalTime(DateTime dateTime, DateTimeKind kind)
 {
     if (dateTime.Kind == kind) return dateTime;
     else
     {
         if (dateTime == DateTime.MinValue) return DateTime.SpecifyKind(DateTime.MinValue, kind);
         else if (dateTime == DateTime.MaxValue) return DateTime.SpecifyKind(DateTime.MaxValue, kind);
         else return DateTime.SpecifyKind(dateTime.ToLocalTime(), kind);
     }
 }