marsdate 1.1.3 → 2.0.0

data/test/test.rb

@@ -1,377 +1,369 @@
-require './lib/marsdate'
+#!/usr/bin/env ruby
+# MarsDateTime constructors on the official MSD timeline.
+# Run: ruby test/test.rb
 
-require 'rubygems'
 require 'minitest/autorun'
-require 'shoulda'
-require 'pp'
+require_relative '../lib/marsdate'
+require 'date'
+
+class MarsDateTest < Minitest::Test
+  def test_civil_ymd_round_trips
+    assert_equal [1, 1, 1, 0, 0, 0], MarsDateTime.new(1, 1, 1).ymshms
+    assert_equal [2, 3, 4, 0, 0, 0], MarsDateTime.new(2, 3, 4).ymshms
+    assert_equal [5, 4, 24, 0, 0, 0], MarsDateTime.new(5, 4, 24).ymshms
+    assert_equal [1054, 20, 20, 0, 0, 0], MarsDateTime.new(1054, 20, 20).ymshms
+  end
 
-class MarsDateTest < MiniTest::Unit::TestCase
+  def test_year1_sol1_is_sunday
+    assert_equal 0, MarsDateTime.new(1, 1, 1).dow
+    assert_equal 'Sunday', MarsDateTime.new(1, 1, 1).day_of_week
+  end
 
-  def my_assert(expr)
-    if !expr && block_given?
-      puts "\n--- DEBUG: "
-      yield 
-    end
-    assert(expr)
+  def test_epoch_msd
+    m = MarsDateTime.new(1, 1, 1)
+    assert_equal MarsDateTime::EPOCH_MSD, m.msd
+    assert_equal 1, m.epoch_sol
   end
 
-  def my_assert_equal(e1, e2)
-    if e1 != e2 && block_given?
-      puts "\n--- DEBUG: "
-      yield 
-    end
-    assert_equal(e1, e2)
+  def test_accessors_ymshms_mxt
+    m = MarsDateTime.new(1043, 2, 15, 12, 34, 45)
+    assert_equal 1043, m.myear
+    assert_equal 2, m.month
+    assert_equal 15, m.sol
+    assert_equal 12, m.mxt_hour
+    assert_equal 34, m.mxt_min
+    assert_in_delta 45.0, m.mxt_sec, 0.001
+    assert_equal 4, m.dow
+    assert_equal 'Thursday', m.day_of_week
+    assert_equal 43, m.year_sol
+    assert_equal 696715, m.epoch_sol
+    assert_equal [1043, 2, 15, 12, 34, 45], m.ymshms
   end
 
-  ## experimenting...
-  
-  context "Mars date 1/1/1" do
-    md = MarsDateTime.new(1,1,1)
-    should "compute backwards to same result" do
-      assert_equal([1,1,1,0,0,0],md.ymshms)
-    end
-    should "be a Sunday" do
-      assert_equal(0,md.dow)
-    end
+  def test_named_constructors
+    a = MarsDateTime.new(1043, 2, 15, 12, 34, 45)
+    b = MarsDateTime.mxt(1043, 2, 15, 12, 34, 45)
+    assert_in_delta 0, a - b, 0
+    assert_equal a.msd, MarsDateTime.at(a.msd).msd
+    assert_equal a.msd, MarsDateTime.from_msd(a.msd).msd
+
+    m = MarsDateTime.mtc(1, 1, 1, 15, 46, 58)
+    assert_equal 15, m.mtc.hour
+    assert_equal 46, m.mtc.min
+    assert_in_delta 58.0, m.mtc.sec, 0.5
+    assert_equal [1, 1, 1], [m.year, m.month, m.sol]
   end
 
-  context "Mars date 2/3/4" do
-    md = MarsDateTime.new(2,3,4)
-    should "compute backwards to same result" do
-      assert_equal([2,3,4,0,0,0],md.ymshms)
-    end
+  def test_mxt_and_mtc_midnight_are_the_same_instant
+    a = MarsDateTime.mxt(1077, 23, 6)
+    b = MarsDateTime.mtc(1077, 23, 6)
+    assert_in_delta 0, a - b, 0
+    assert_equal 0, a.mxt.hour
+    assert_equal 0, a.mtc.hour
   end
 
-  context "Mars date 5/4/24" do
-    md = MarsDateTime.new(5,4,24)
-    should "compute backwards to same result" do
-      assert_equal([5,4,24,0,0,0],md.ymshms)
-    end
+  def test_clock_views
+    m = MarsDateTime.mxt(1, 1, 1, 13, 0, 0)
+    assert_equal 13, m.mxt.hour
+    assert_equal 0, m.mxt.min
+    assert_in_delta 0.0, m.mxt.sec, 0.001
+    assert_equal :mxt, m.mxt.scale
+    assert_equal :mtc, m.mtc.scale
+    assert_equal m.format_mxt, m.mxt.to_s
+    assert_equal m.format_mtc, m.mtc.to_s
+    assert_equal '13', m.format('%H')
+    assert_equal '13', m.format_mxt('%H')
+    assert_equal '13', m.mxt.format('%H')
+    assert_equal '12', m.format_mtc('%H')
+    assert_equal '12', m.mtc.format('%H')
+    assert_equal 'MXT', m.format('%Z')
+    assert_equal 'MXT', m.mxt.format('%Z')
+    assert_equal 'MTC', m.format_mtc('%Z')
+    assert_equal 'MTC', m.mtc.format('%Z')
+    assert_equal '13:00:00 MXT', m.format('%H:%M:%S %Z')
+    assert_equal '12:39:07 MTC', m.format_mtc('%H:%M:%S %Z')
+    assert_equal m.year, m.mxt.year
+    assert_equal m.month_name, m.mtc.month_name
+    refute_respond_to m, :strftime
   end
 
-  context "Mars date 1054/20/20" do
-    md = MarsDateTime.new(1054,20,20)
-    should "compute backwards to same result" do
-      assert_equal([1054,20,20,0,0,0],md.ymshms)
-    end
+  def test_at_rolls_into_next_sol
+    midnight = MarsDateTime.mxt(1, 1, 1)
+    nxt = MarsDateTime.at(midnight.msd + 1)
+    assert_equal [1, 1, 2], [nxt.year, nxt.month, nxt.sol]
   end
 
-  context "Earth date 1/1/22" do
-    ed = DateTime.new(1,1,22)
-    md = MarsDateTime.new(ed)
-    should "be approximately M-date 1/1/1" do
-      assert_equal([1,1,1],md.ymshms[0..2])
-    end
-    should "yield a Martian Sunday" do
-      assert_equal(md.day_of_week,"Sunday")
-    end
+  def test_accessors_933
+    m = MarsDateTime.new(933, 1, 2)
+    assert_equal [933, 1, 2], [m.myear, m.month, m.sol]
+    m = MarsDateTime.new(933, 1, 1)
+    assert_equal [933, 1, 1], [m.myear, m.month, m.sol]
   end
 
-  context "Earth date May 23, 1961" do
-    e = DateTime.new(1961,5,23)
-    m = MarsDateTime.new(e)
-    should "yield a Martian Friday" do
-      assert_equal(m.day_of_week,"Friday")
-    end
+  def test_taurus_25_leap_only
+    assert MarsDateTime.leap?(1067)
+    MarsDateTime.new(1067, 24, 25)
+    refute MarsDateTime.leap?(1066)
+    assert_raises(ArgumentError) { MarsDateTime.new(1066, 24, 25) }
   end
 
-  context "Earth date May 24, 1961" do
-    e = DateTime.new(1961,5,24)
-    m = MarsDateTime.new(e)
-    should "yield a Martian Saturday" do
-      assert_equal(m.day_of_week,"Saturday")
-#     my_assert_equal(m.day_of_week,"Friday") { p m }
-    end
+  def test_reject_invalid_clocks
+    assert_raises(ArgumentError) { MarsDateTime.new(1, 1, 1, 24, 40, 0) }
+    assert_raises(ArgumentError) { MarsDateTime.mtc(1, 1, 1, 24, 0, 0) }
+    assert_raises(ArgumentError) { MarsDateTime.new(1, 1, 1, 25, 0, 0) }
+    MarsDateTime.new(1, 1, 1, 24, 39, 35) # last MXT second, ok
   end
 
-  context "A Martian date/time (y,m,s,h,m,s)" do   ###
-    m = MarsDateTime.new(1043,2,15,12,34,45)
-    should "set all its accessors properly" do
-      assert_equal(1043,m.myear)
-      assert_equal(2,m.month)
-      assert_equal(15,m.sol)
-      assert_equal(12,m.hr)
-      assert_equal(34,m.min)
-      assert_equal(45,m.sec)
-      assert_equal(4,m.dow)
-      assert_equal("Thursday",m.day_of_week)
-      assert_equal(43,m.year_sol)
-      assert_equal(696715,m.epoch_sol)
-    end
+  def test_earth_before_epoch_rejected
+    assert_raises(ArgumentError) { MarsDateTime.new(DateTime.new(1, 1, 22)) }
   end
 
-  context "The 2007 Martian equinox" do  ###
-    e = DateTime.new(2007,12,9,17,20,0)
-    m = MarsDateTime.new(e)
-    m11 = MarsDateTime.new(1068,1,1)
-    should "fall on or near 1/1 (MCE)" do
-      diff = (m11-m).abs
-      flag = diff < 1.5
-      assert(flag)
-    end
+  def test_official_mtc_examples
+    m = MarsDateTime.new(DateTime.new(2000, 1, 6, 0, 0, 0))
+    assert_equal [1063, 19, 21], [m.year, m.month, m.sol]
+    assert_equal 23, m.mtc_hour
+    assert_equal 59, m.mtc_min
+    assert_in_delta 39.3, m.mtc_sec, 1.0
+
+    m = MarsDateTime.new(DateTime.new(2026, 8, 13, 0, 6, 56))
+    assert_equal [1077, 23, 6], [m.year, m.month, m.sol]
+    mtc_hours = m.mtc_hour + m.mtc_min / 60.0 + m.mtc_sec / 3600.0
+    assert_in_delta 1 + 6 / 60.0 + 22 / 3600.0, mtc_hours, 2.0 / 3600.0
   end
 
-  context "Constructing without parameters" do
-    m = MarsDateTime.new
-    e = DateTime.now
-    m2e = m.earth_date
-    should "default to today" do
-      diff = (e-m2e).abs     # m - e doesn't work!
-      assert(diff < 1.0)
-    end
+  def test_offset_independent
+    utc = DateTime.new(2000, 1, 1, 12, 0, 0)
+    est = utc.new_offset(Rational(-5, 24))
+    assert_in_delta MarsDateTime.new(utc).msd, MarsDateTime.new(est).msd, 1e-12
   end
 
-  context "Constructing with a DateTime" do
-    should "convert from Gregorian to MCE" do
-      e = DateTime.new(1902,8,12,7,0,0)
-      m = MarsDateTime.new(e)
-      diff = (m.earth_date - e).abs   # days as a float
-      x = assert(diff < 1.0)
-    end
+  def test_equinoxes_near_following_new_year
+    m = MarsDateTime.new(DateTime.new(2007, 12, 9, 17, 20, 0))
+    assert_in_delta 0, MarsDateTime.new(1068, 1, 1) - m, 1.5
+
+    m = MarsDateTime.new(DateTime.new(1609, 3, 12))
+    assert_in_delta 0, MarsDateTime.new(856, 1, 1) - m, 1.5
+
+    m = MarsDateTime.new(DateTime.new(1902, 8, 12, 7, 0, 0))
+    assert_in_delta 0, MarsDateTime.new(1012, 1, 1) - m, 1.5
   end
 
-  context "A Martian date/time (933,1,2)" do
-    m = MarsDateTime.new(933,1,2)
-    should "set the three obvious accessors properly" do
-      assert_equal(933,m.myear)
-      assert_equal(1,m.month)
-      assert_equal(2,m.sol)
-    end
+  def test_default_constructor_is_now
+    assert_in_delta 0, DateTime.now - MarsDateTime.new.earth_date, 1.0
   end
 
-  context "A Martian date/time (933,1,1)" do
-    m = MarsDateTime.new(933,1,1)
-    should "set the three obvious accessors properly" do
-      assert_equal(933,m.myear)
-      assert_equal(1,m.month)
-      assert_equal(1,m.sol)
-    end
+  def test_today_is_current_mars_midnight
+    n = MarsDateTime.now
+    t = MarsDateTime.today
+    assert_equal n.year, t.year
+    assert_equal n.month, t.month
+    assert_equal n.sol, t.sol
+    assert_equal 0, t.mxt_hour
+    assert_equal 0, t.mxt_min
+    assert_in_delta 0.0, t.mxt_sec, 1e-9
+    assert_in_delta 0.0, t.mtc_hour, 1e-9
+    assert_operator n.msd - t.msd, :>=, 0
+    assert_operator n.msd - t.msd, :<, 1.0
   end
 
-  context "The Martian date 24/25" do
-    context "in a leap year" do
-      year = 1067
-      should "exist" do
-        assert( MarsDateTime.leap?(year) )
-        assert_nothing_raised { MarsDateTime.new(year,24,25) }
-      end
-    end
-    context "in a non-leap year" do
-      year = 1066
-      should "not exist" do
-        assert( ! MarsDateTime.leap?(year) )
-        assert_raise(RuntimeError) { MarsDateTime.new(year,24,25) }
-      end
-    end
+  def test_earth_date_of_mars_epoch
+    e = MarsDateTime.new(1, 1, 1).earth_date
+    assert_equal 1, e.year
+    assert_equal 1, e.month
+    assert_in_delta 23, e.day, 1
+    cap = MarsDateTime.epoch_caption
+    assert_equal e.year, cap[:epoch_earth_if_tt_were_ut].year
+    assert_equal e.day, cap[:epoch_earth_if_tt_were_ut].day
+    assert_match(/TT as UT/, cap[:caveat])
   end
 
-  context "The earth_date convertor" do
-    m = MarsDateTime.new(1,1,1)
-    should "convert to a Gregorian date" do
-      e = m.earth_date
-      assert_equal(1,e.year)
-      assert_equal(1,e.month)
-      assert((e.day-22).abs <= 1)
-    end
+  def test_earth_datetime_round_trip
+    e = DateTime.new(1902, 8, 12, 7, 0, 0)
+    assert_in_delta 0, MarsDateTime.new(e).earth_date - e, 1.0 / 86400.0
   end
 
-  context "An Earthly date" do
-    e1 = DateTime.new(1961,5,31)
-    should "(approximately) make the conversion roundtrip" do
-      m1 = MarsDateTime.new(e1)
-      e2 = m1.earth_date
-      diff = e2 - e1
-      assert(diff.abs <= 0.01)
-    end
+  def test_earth_round_trip
+    e1 = DateTime.new(1961, 5, 31)
+    e2 = MarsDateTime.new(e1).earth_date
+    assert_in_delta 0, e2 - e1, 1.0 / 86400.0
   end
 
-  context "A Martian date" do
-    m1 = MarsDateTime.new(1067,1,1)
-    should "(approximately) make the conversion roundtrip" do
-      e1 = m1.earth_date
-      m2 = MarsDateTime.new(e1)
-      diff = m2 - m1
-      assert(diff.abs < 0.01)
-    end
+  def test_mars_round_trip
+    m1 = MarsDateTime.new(1067, 1, 1)
+    m2 = MarsDateTime.new(m1.earth_date)
+    assert_in_delta 0, m2 - m1, 1e-8
   end
 
-  context "An arbitrary Martian date" do
-    m1 = MarsDateTime.new(1069,15,24)
-    m2 = MarsDateTime.new(933,6,4)
-    m3 = MarsDateTime.new(1055,14,1)
-    should "format well with strftime" do
-      assert_equal("Mon",m1.strftime("%a"))
-      assert_equal("Monday",m1.strftime("%A"))
-      assert_equal("Aug",m1.strftime("%b"))
-      assert_equal("August",m1.strftime("%B"))
-      assert_equal("24",m1.strftime("%d"))
-      assert_equal("24",m1.strftime("%e"))
-      assert_equal("1069-15-24",m1.strftime("%F"))
-      assert_equal("416",m1.strftime("%j"))
-      assert_equal("15",m1.strftime("%m"))
-      assert_equal("0",m1.strftime("%s"))
-      assert_equal("2",m1.strftime("%u"))
-      assert_equal("60",m1.strftime("%U"))
-      assert_equal("1",m1.strftime("%w"))
-      assert_equal("1069/15/24",m1.strftime("%x"))
-      assert_equal("1069",m1.strftime("%Y"))
-      assert_equal("\n",m1.strftime("%n"))
-      assert_equal("\t",m1.strftime("%t"))
-      assert_equal("%",m1.strftime("%%"))
-  
-      assert_equal("Wed",m2.strftime("%a"))
-      assert_equal("Wednesday",m2.strftime("%A"))
-      assert_equal("Leo",m2.strftime("%b"))
-      assert_equal("Leo",m2.strftime("%B"))
-      assert_equal("04",m2.strftime("%d"))
-      assert_equal(" 4",m2.strftime("%e"))
-      assert_equal("933-6-4",m2.strftime("%F"))
-      assert_equal("144",m2.strftime("%j"))
-      assert_equal("6",m2.strftime("%m"))
-      assert_equal("0",m2.strftime("%s"))
-      assert_equal("4",m2.strftime("%u"))
-      assert_equal("21",m2.strftime("%U"))
-      assert_equal("3",m2.strftime("%w"))
-      assert_equal("933/06/04",m2.strftime("%x"))
-      assert_equal("933",m2.strftime("%Y"))
-  
-      assert_equal("Sag",m3.strftime("%b"))
-      assert_equal("Sagittarius",m3.strftime("%B"))
+  def test_earth_round_trip_with_hms
+    e1 = DateTime.new(1976, 7, 4, 16, 30, 0)
+    30.times do
+      e2 = MarsDateTime.new(e1).earth_date
+      assert_in_delta 0, e2 - e1, 1.0 / 86400.0
+      e1 += 1
     end
   end
 
-  context "An Earthly date with h:m:s" do
-    e1 = DateTime.new(1976,7,4,16,30,0)  # July 4, 1976  16:30
-    m1 = MarsDateTime.new(e1)
-    should "make the conversion roundtrip" do
-      30.times do
-        m1 = MarsDateTime.new(e1)
-        e2 = m1.earth_date
-        diff = e2 - e1
-        assert(diff.abs <= 0.01) { STDERR.puts "    diff = #{diff}" }
-        e1 += 1
-      end
-    end
+  def test_format_dates
+    m1 = MarsDateTime.new(1069, 15, 24)
+    m2 = MarsDateTime.new(933, 6, 4)
+    m3 = MarsDateTime.new(1055, 14, 1)
+
+    assert_equal 'Mon', m1.format('%a')
+    assert_equal 'Monday', m1.format('%A')
+    assert_equal 'Aug', m1.format('%b')
+    assert_equal 'M-August', m1.format('%B')
+    assert_equal '24', m1.format('%d')
+    assert_equal '24', m1.format('%e')
+    assert_equal '1069-15-24', m1.format('%F')
+    assert_equal '416', m1.format('%j')
+    assert_equal '15', m1.format('%m')
+    assert_equal '0', m1.format('%s')
+    assert_equal '2', m1.format('%u')
+    assert_equal '60', m1.format('%U')
+    assert_equal '1', m1.format('%w')
+    assert_equal '1069/15/24', m1.format('%x')
+    assert_equal '1069', m1.format('%Y')
+    assert_equal "\n", m1.format('%n')
+    assert_equal "\t", m1.format('%t')
+    assert_equal '%', m1.format('%%')
+
+    assert_equal 'Wed', m2.format('%a')
+    assert_equal 'Wednesday', m2.format('%A')
+    assert_equal 'Leo', m2.format('%b')
+    assert_equal 'Leo', m2.format('%B')
+    assert_equal '04', m2.format('%d')
+    assert_equal ' 4', m2.format('%e')
+    assert_equal '933-06-04', m2.format('%F')
+    assert_equal '144', m2.format('%j')
+    assert_equal '06', m2.format('%m')
+    assert_equal '0', m2.format('%s')
+    assert_equal '4', m2.format('%u')
+    assert_equal '21', m2.format('%U')
+    assert_equal '3', m2.format('%w')
+    assert_equal '933/06/04', m2.format('%x')
+    assert_equal '933', m2.format('%Y')
+
+    assert_equal 'Sag', m3.format('%b')
+    assert_equal 'Sagittarius', m3.format('%B')
+
+    line = '%A, %B %e, %Y %H:%M:%S'
+    assert_equal m1.format(line), m1.format_mxt(line)
+    assert_equal m1.format(line), m1.mxt.format(line)
+    assert_equal m1.format_mtc(line), m1.mtc.format(line)
   end
 
-   context "Martian dates" do
-     m1 = MarsDateTime.new(1068,14,22)
-     m2 = MarsDateTime.new(1068,14,21)
-     e1 = DateTime.new(2002,4,19)
-     e2 = DateTime.new(2012,9,29)
-     should "compare with each other" do
-       assert(m1 > m2)
-       assert(m2 < m1)
-     end
-     should "compare with Earth dates" do
-       assert(m1 > e1)
-       assert(m2 < e2)
-     end
-     should "honor equality (within roundoff)" do
-       assert(m1 == m1)
-       assert(m1 != m2)
-     end
-   end
-
-  context "The 'now' and 'today' class methods" do
-    t1 = MarsDateTime.now
-    t0 = MarsDateTime.today
-    should "be less than a day apart" do
-      diff = t1 - t0
-      assert(diff < 1.0)
-    end
+  def test_format_clocks_at_midnight
+    m = MarsDateTime.new(1, 1, 1)
+    assert_equal '00', m.format('%H')
+    assert_equal '00', m.format_mtc('%H')
+    assert_equal '00:00:00', m.format('%X')
+    assert_equal '%P', m.format('%P')
+    assert_equal 'foo%', m.format('foo%')
+    assert_equal '%', m.format('%')
+    assert_equal 'x%', m.format('x%%')
   end
 
-  context "In M-year 1043, each month" do
-    md = (1..24).to_a.map {|mm| MarsDateTime.new(1043,mm,1) }
-    should "start on a Thursday" do
-      md.each {|m| assert(m.day_of_week == "Thursday") }
-    end
+  def test_mtc_just_before_midnight_stays_on_previous_sol
+    next_midnight = (MarsDateTime::EPOCH_MSD + 11).to_f
+    m = MarsDateTime.at(next_midnight.prev_float)
+
+    assert_equal [1, 1, 11], [m.year, m.month, m.sol]
+    assert_equal [23, 59], [m.mtc_hour, m.mtc_min]
+    assert_operator m.mtc_sec, :<, 60
+    assert_equal '23:59:59.999', m.format_mtc
+    assert_equal '23:59:59 MTC', m.format_mtc('%H:%M:%S %Z')
   end
 
-  context "Converting 1961/5/31 to Martian" do
-    e = DateTime.new(1961,5,31) 
-    m = MarsDateTime.new(e)
-    should "yield M-April 10, 1043 MCE" do
-      assert(m.year == 1043)
-      assert(m.month == 7)
-      assert(m.sol == 10)
-    end
-    should "give a Martian Saturday" do
-      assert(m.day_of_week == "Saturday")
-    end
+  def test_date_is_a_valid_operand
+    d = Date.new(2010, 1, 1)
+    m = MarsDateTime.new(d)
+    assert_in_delta 0, m - d, 1e-9
+    assert_equal 0, m <=> d
   end
 
-  context "The 1609 Martian equinox" do
-    e = DateTime.new(1609,3,12)
-    m = MarsDateTime.new(e)
-    m11 = MarsDateTime.new(856,1,1)
-    should "fall on or near 1/1 (MCE)" do
-      diff = (m11-m).abs
-      assert(diff < 1.5)
-    end
+  def test_taurus_past_end_is_rejected
+    assert_raises(ArgumentError) { MarsDateTime.new(1, 24, 26) }
+    assert_raises(ArgumentError) { MarsDateTime.new(1, 24, 28) }
   end
 
-  context "The 1902 Martian equinox" do
-    e = DateTime.new(1902,8,12,7,0,0)
-    m = MarsDateTime.new(e)
-    m11 = MarsDateTime.new(1012,1,1)
-    should "fall on or near 1/1 (MCE)" do
-      diff = (m11-m).abs
-      assert(diff < 1.5)
-    end
+  def test_comparisons
+    m1 = MarsDateTime.new(1068, 14, 22)
+    m2 = MarsDateTime.new(1068, 14, 21)
+    e1 = DateTime.new(2002, 4, 19)
+    e2 = DateTime.new(2012, 9, 29)
+    assert_operator m1, :>, m2
+    assert_operator m2, :<, m1
+    assert_operator m1, :>, e1
+    assert_operator m2, :<, e2
+    assert_equal m1, m1
+    refute_equal m1, m2
   end
 
-  context "A Martian date" do
-    m = MarsDateTime.new(1068,1,1)
-    context "plus 7 days" do
-      m2 = m + 7
-      should "be the same day of the week" do
-        assert_equal(m.day_of_week, m2.day_of_week)
-      end
-    end
-    context "plus 14 days" do
-      m3 = m + 14
-      should "be the same day of the week" do
-        assert_equal(m.day_of_week, m3.day_of_week)
-      end
-    end
-    context "plus 21 days" do
-      m4 = m + 21
-      should "be the same day of the week" do
-        assert_equal(m.day_of_week, m4.day_of_week)
-      end
+  def test_year_1043_months_start_thursday
+    (1..24).each do |mm|
+      assert_equal 'Thursday', MarsDateTime.new(1043, mm, 1).day_of_week
     end
   end
 
-  context "Martian April 1, 1043" do
-    m = MarsDateTime.new(1043,7,1)
-    should "be a Thursday" do
-      assert_equal(m.day_of_week,"Thursday")
-    end
+  def test_earth_1961_may_31
+    m = MarsDateTime.new(DateTime.new(1961, 5, 31))
+    assert_equal 1043, m.year
+    assert_equal 7, m.month
+    assert_equal 8, m.sol
+    assert_equal 'Thursday', m.day_of_week
   end
- 
-  context "A Martian date" do
-    md = MarsDateTime.new(1062,20,20)
-    m2 = MarsDateTime.new(1062,20,17) 
-    should "allow subtraction of another date" do
-      m = md - m2
-      assert( (m - 3.0) < 0.01)   # sols
-    end
-    should "allow subtraction of an Earth date" do
-      e = DateTime.new(1998, 3, 12, 16, 45, 0)
-      m = md - e
-      assert( (m - 3.0) < 0.01)   # sols
-    end
-    should "allow subtraction of a Fixnum" do
-      m = md - 3                 # sols
-      assert( (m - m2) < 0.01)
-    end
-    should "allow subtraction of a Float" do
-      m = md - 3.0               # sols
-      assert( (m - m2) < 0.01)
-    end
+
+  def test_martian_april_1_1043_is_thursday
+    assert_equal 'Thursday', MarsDateTime.new(1043, 7, 1).day_of_week
   end
 
-end
+  def test_plus_weeks_keeps_weekday
+    m = MarsDateTime.new(1068, 1, 1)
+    assert_equal m.day_of_week, (m + 7).day_of_week
+    assert_equal m.day_of_week, (m + 14).day_of_week
+    assert_equal m.day_of_week, (m + 21).day_of_week
+  end
+
+  def test_addition_rolls_year
+    assert_equal [1067, 1, 1], (MarsDateTime.new(1066, 24, 24) + 1).ymshms[0..2]
+    assert_equal [1068, 1, 1], (MarsDateTime.new(1067, 24, 25) + 1).ymshms[0..2]
+  end
+
+  def test_subtraction
+    md = MarsDateTime.new(1062, 20, 20)
+    m2 = MarsDateTime.new(1062, 20, 17)
+    assert_in_delta 3.0, md - m2, 1e-9
+    assert_in_delta 0, (md - 3) - m2, 1e-9
+    assert_in_delta 0, (md - 3.0) - m2, 1e-9
+    e = m2.earth_date
+    assert_in_delta 3.0, md - e, 1e-8
+    d = Date.new(2000, 1, 1)
+    dt = DateTime.new(2000, 1, 1, 12, 0, 0)
+    assert MarsDateTime.new(dt) - d > 0
+    assert_equal 1, MarsDateTime.new(dt) <=> d
+  end
 
+  def test_from_msd_and_json
+    m = MarsDateTime.new(1043, 2, 15, 12, 34, 45)
+    m2 = MarsDateTime.from_msd(m.msd)
+    assert_in_delta 0, m2 - m, 0
+    m3 = MarsDateTime.from_json(m.to_json)
+    assert_in_delta 0, m3 - m, 0
+    assert_equal m.msd, MarsDateTime.new(m.msd).msd
+  end
+
+  def test_to_s_labels_both_clocks
+    s = MarsDateTime.new(1, 1, 1).to_s
+    assert_includes s, 'MXT'
+    assert_includes s, 'MTC'
+    refute_match(/\bhr\b/, s)
+  end
+
+  def test_no_unmarked_clock_accessors
+    m = MarsDateTime.new(1, 1, 1)
+    refute m.respond_to?(:hr)
+    refute m.respond_to?(:min)
+    refute m.respond_to?(:sec)
+    assert_raises(ArgumentError) { MarsDateTime.new(1, 1, 1, 0, 0, 0, clock: :mtc) }
+  end
+end