static void Main()
 {
     Time Now = new Time(12, 34, 56);
     Console.WriteLine((int)Now);
     Console.WriteLine((double)Now);
     Console.WriteLine(Now);
 }

 public void can_extract_time_from_datetime()
 {
     var compareTime = new Time(13, 59);
     var dateTime = new DateTime(2011, 3, 5, 13, 59, 0);
     var time = dateTime.TimeOfTheDay();
     Assert.AreEqual(time, compareTime);
 }

 public void can_parse_time_two_digit_hours()
 {
     var compareTime = new Time(13, 59);
     string timeValue = "13:59:00";
     var time = timeValue.ToTimeOfDay();
     Assert.AreEqual(time, compareTime);
 }

 public AnimatedSprite(Time frameTime, bool paused, bool looped)
 {
     FrameTime = frameTime;
     Pause = paused;
     Loop = looped;
     _vertices = new Vertex[4];
 }

        public void Update(Time deltaTime)
        {
            if (Pause || Animation == null) return;

            // add delta time
            _currentTime += deltaTime;

            // if current time is bigger than frame time, advance one frame
            if (_currentTime <= FrameTime) return;

            // reset time, but keep remainder
            _currentTime = _currentTime % FrameTime;

            // get next frame index
            if (_currentFrame + 1 < Animation.Frames.Count)
            {
                _currentFrame++;
            }
            else
            {
                // animation has ended
                _currentFrame = 0;

                if (!Loop)
                {
                    Pause = true;
                }
            }

            SetFrame(_currentFrame, false);
        }

 static void Main()
 {
     Time Now = new Time(12, 34, 56);
     Now.OutTime();
     Now["분"] = 19;
     Console.WriteLine("분은 {0}입니다.", Now["분"]);
 }

 public void Can_Add_Minutes()
 {
     Time time = new Time(22, 30);
     time = time.AddMinutes(105);
     Assert.AreEqual(0, time.Hour);
     Assert.AreEqual(15, time.Minute);
 }

 public void can_format_24hour_time()
 {
     var compareTime = new Time(13, 59, 58, "HH:mm:ss");
     var time = compareTime.ToString();
     string timeValue = "13:59:58";
     Assert.AreEqual(time, timeValue);
 }

		/** == Time units
		 * Whenever durations need to be specified, eg for a timeout parameter, the duration can be specified
		 * as a whole number representing time in milliseconds, or as a time value like `2d` for 2 days.
		 *
		 * === Using Time units in NEST
		 * NEST uses `Time` to strongly type this and there are several ways to construct one.
		 *
		 * ==== Constructor
		 * The most straight forward way to construct a `Time` is through its constructor
		 */
		[U] public void Constructor()
		{
			var unitString = new Time("2d");
			var unitComposed = new Time(2, Nest.TimeUnit.Day);
			var unitTimeSpan = new Time(TimeSpan.FromDays(2));
			var unitMilliseconds = new Time(1000 * 60 * 60 * 24 * 2);

			/**
			* When serializing Time constructed from
			* - a string
			* - milliseconds (as a double)
			* - composition of factor and interval
			* - a `TimeSpan`
			*
			* the expression will be serialized to a time unit string composed of the factor and interval e.g. `2d`
			*/
			Expect("2d")
				.WhenSerializing(unitString)
				.WhenSerializing(unitComposed)
				.WhenSerializing(unitTimeSpan)
				.WhenSerializing(unitMilliseconds);

			/**
			* The `Milliseconds` property on `Time` is calculated even when not using the constructor that takes a double
			*/
			unitMilliseconds.Milliseconds.Should().Be(1000*60*60*24*2);
			unitComposed.Milliseconds.Should().Be(1000*60*60*24*2);
			unitTimeSpan.Milliseconds.Should().Be(1000*60*60*24*2);
			unitString.Milliseconds.Should().Be(1000*60*60*24*2);
		}

 public void VerifyAllEnums()
 {
     var acceleration = new Acceleration(1, AccelerationUnit.BaseUnit);
     var angle = new Angle(1, AngleUnit.BaseUnit);
     var angularAcceleration = new AngularAcceleration(1, AngularAccelerationUnit.BaseUnit);
     var area = new Area(1, AreaUnit.BaseUnit);
     var density = new MassDensity(1, MassDensityUnit.BaseUnit);
     var electricCurrent = new ElectricCurrent(1, ElectricCurrentUnit.BaseUnit);
     var electricResistance = new ElectricResistance(1, ElectricResistanceUnit.BaseUnit);
     var electricVoltage = new ElectricPotential(1, ElectricPotentialUnit.BaseUnit);
     var energy = new Energy(1, EnergyUnit.BaseUnit);
     var force = new Force(1, ForceUnit.BaseUnit);
     var frequency = new Frequency(1, FrequencyUnit.BaseUnit);
     var jerk = new Jerk(1, JerkUnit.BaseUnit);
     var length = new Length(1, LengthUnit.BaseUnit);
     var mass = new Mass(1, MassUnit.BaseUnit);
     var massFlowRate = new MassFlowRate(1, MassFlowRateUnit.BaseUnit);
     var momentum = new Momentum(1, MomentumUnit.BaseUnit);
     var numeric = new Numeric(1, NumericUnit.BaseUnit);
     var power = new Power(1, PowerUnit.BaseUnit);
     var pressure = new Pressure(1, PressureUnit.BaseUnit);
     var speed = new Speed(1, SpeedUnit.BaseUnit);
     var temperature = new Temperature(1, TemperatureUnit.BaseUnit);
     var time = new Time(1, TimeUnit.BaseUnit);
     var torque = new Torque(1, TorqueUnit.BaseUnit);
     var volume = new Volume(1, VolumeUnit.BaseUnit);
     var volumetricFlowRate = new VolumetricFlowRate(1, VolumetricFlowRateUnit.BaseUnit);
 }

 public void can_format_12hour_time()
 {
     var compareTime = new Time(13, 59, 58, "h:mm:ss tt");
     var time = compareTime.ToString();
     string timeValue = "1:59:58 " + Thread.CurrentThread.CurrentCulture.DateTimeFormat.PMDesignator;
     Assert.AreEqual(time, timeValue);
 }

 public static StrategyDecision New(
     Directive processDirective,
     MessageDirective messageDirective,
     IEnumerable<ProcessId> affects,
     Time pause
 ) =>
     new StrategyDecision(processDirective, messageDirective, affects, pause);

 public Report(Time time, IState state)
 {
     if(null == state)
         throw new ArgumentNullException("state");
     _time = time;
     _state = state;
 }

 public Call (DateTime date, Time time, string dialledPhoneNumber, int duration)
 {
     this.Date = date;
     this.Time = time;
     this.DialledPhoneNumber = dialledPhoneNumber;
     this.Duration = duration;
 }

 public TimeSlot(int number, Time startTime, TimeSpan duration, bool isAvailable)
 {
     Number = number;
     StartTime = startTime;
     Duration = duration;
     IsAvailable = isAvailable;
 }

        StrategyContext(
            StrategyState global,
            Exception exception,
            object message,
            ProcessId sender,
            ProcessId failedProcess,
            ProcessId parentProcess,
            IEnumerable<ProcessId> siblings,
            IEnumerable<ProcessId> affects,
            Time pause,
            Option<Directive> directive,
            Option<MessageDirective> messageDirective
            )
        {
            bool isStop = directive == LanguageExt.Directive.Stop;

            Global = isStop ? StrategyState.Empty : global;
            Exception = exception;
            Message = message;
            Sender = sender;
            Self = failedProcess;
            ParentProcess = parentProcess;
            Siblings = siblings ?? Siblings;
            Affects = affects ?? Affects;
            Pause = isStop ? 0 * s : pause;
            Directive = directive;
            MessageDirective = messageDirective;
        }

 internal Gregorian(Time time, TimeZone timezone)
 {
     this.time = time;
     if (timezone == null)
         timezone = time.Context.Gmt ();
     this.timezone = timezone;
 }

        public CreateWIP1(BatchTreeViewItem sender)
        {
            Sender = sender;
            // WorkItem happens after you click

            InitializeComponent();

            // Do Not Run Until Time
            Time timeUntilTime = new Time(false);
            dataTableUntil = timeUntilTime.TimeDataTable;
            timeUntil.ItemsSource = dataTableUntil.AsDataView();

            // Do Not Run After Time
            Time timeAfterTime = new Time(false); // heh
            dataTableAfter = timeAfterTime.TimeDataTable;
            timeAfter.ItemsSource = dataTableAfter.AsDataView();

            // Recurrence Interval
            Time recurrenceIntervalTime = new Time(true);
            dataTableInterval = recurrenceIntervalTime.TimeDataTable;
            dataGridInterval.ItemsSource = dataTableInterval.AsDataView();

            // Start Window
            Time startWindowTime = new Time(true);
            dataTableWindow = startWindowTime.TimeDataTable;
            dataGridWindow.ItemsSource = dataTableWindow.AsDataView();

            Loaded += OnLoaded;

            MainWindow.Resize(MainGrid);
        }

 protected override void Update(Time time)
 {
     sateenkaari.X = (lanta.X + hahmo.X)/2;
     sateenkaari.Y = hahmo.Y;
     sateenkaari.Width = hahmo.X - lanta.X;
     base.Update(time);
 }

        public IRun Create(IComparisonGeneratorsFactory factory)
        {
            var run = new Run(factory);

            var reader = new StreamReader(Stream);
            
            var line = reader.ReadLine();
            var titleInfo = line.Split('|');
            run.CategoryName = titleInfo[0].Substring(1);
            run.AttemptCount = int.Parse(titleInfo[1]);
            TimeSpan totalTime = TimeSpan.Zero;
            while ((line = reader.ReadLine()) != null)
            {
                if (line.Length > 0)
                {
                    var majorSplitInfo = line.Split('|');
                    totalTime += TimeSpanParser.Parse(majorSplitInfo[1]);
                    while (!reader.EndOfStream && reader.Read() == '*')
                    {
                        line = reader.ReadLine();
                        run.AddSegment(line);
                    }
                    var newTime = new Time(run.Last().PersonalBestSplitTime);
                    newTime.GameTime = totalTime;
                    run.Last().PersonalBestSplitTime = newTime;
                }
                else
                {
                    break;
                }
            }

            return run;
        }