gpx 0.8.3 → 1.1.1

data/tests/segment_test.rb

@@ -1,109 +1,120 @@
-#require 'minitest/autorun'
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'yaml'
 require 'gpx'
 
 class SegmentTest < Minitest::Test
-   ONE_SEGMENT = File.join(File.dirname(__FILE__), "gpx_files/one_segment.gpx")
-   ONE_SEGMENT_NO_TIME = File.join(File.dirname(__FILE__), "gpx_files/one_segment_no_time.gpx")
+  ONE_SEGMENT = File.join(File.dirname(__FILE__), 'gpx_files/one_segment.gpx')
+  ONE_SEGMENT_NO_TIME = File.join(File.dirname(__FILE__), 'gpx_files/one_segment_no_time.gpx')
+  ONE_SEGMENT_MIXED_TIMES = File.join(File.dirname(__FILE__), 'gpx_files/one_segment_mixed_times.gpx')
 
-   def setup
-      @gpx_file = GPX::GPXFile.new(:gpx_file => ONE_SEGMENT)
-      @segment = @gpx_file.tracks.first.segments.first
-   end
+  def setup
+    @gpx_file = GPX::GPXFile.new(gpx_file: ONE_SEGMENT)
+    @segment = @gpx_file.tracks.first.segments.first
+  end
 
-   def test_segment_read
-      assert_equal(189, @segment.points.size)
-      assert_equal(1144433525, @segment.earliest_point.time.to_i)
-      assert_equal(1144437991, @segment.latest_point.time.to_i)
-      assert_equal(1334.447, @segment.lowest_point.elevation)
-      assert_equal(1480.087, @segment.highest_point.elevation)
-      assert_in_delta(6.98803359528853, @segment.distance, 0.001)
-      assert_equal(4466.0, @segment.duration)
-   end
+  def test_segment_read
+    assert_equal(189, @segment.points.size)
+    assert_equal(1_144_433_525, @segment.earliest_point.time.to_i)
+    assert_equal(1_144_437_991, @segment.latest_point.time.to_i)
+    assert_equal(1334.447, @segment.lowest_point.elevation)
+    assert_equal(1480.087, @segment.highest_point.elevation)
+    assert_in_delta(6.98803359528853, @segment.distance, 0.001)
+    assert_equal(4466.0, @segment.duration)
+  end
 
-   def test_segment_read_no_time
-      gpx_file_no_time = GPX::GPXFile.new(:gpx_file => ONE_SEGMENT_NO_TIME)
-      segment_no_time = gpx_file_no_time.tracks.first.segments.first
-      assert_equal(189, segment_no_time.points.size)
-      assert_equal(1334.447, segment_no_time.earliest_point.elevation)
-      assert_equal(1413.756, segment_no_time.latest_point.elevation)
-      assert_equal(1334.447, segment_no_time.lowest_point.elevation)
-      assert_equal(1480.087, segment_no_time.highest_point.elevation)
-      assert_in_delta(6.98803359528853, segment_no_time.distance, 0.001)
-      assert_equal(0, segment_no_time.duration)
-   end
+  def test_segment_read_no_time
+    gpx_file_no_time = GPX::GPXFile.new(gpx_file: ONE_SEGMENT_NO_TIME)
+    segment_no_time = gpx_file_no_time.tracks.first.segments.first
+    assert_equal(189, segment_no_time.points.size)
+    assert_equal(1334.447, segment_no_time.earliest_point.elevation)
+    assert_equal(1413.756, segment_no_time.latest_point.elevation)
+    assert_equal(1334.447, segment_no_time.lowest_point.elevation)
+    assert_equal(1480.087, segment_no_time.highest_point.elevation)
+    assert_in_delta(6.98803359528853, segment_no_time.distance, 0.001)
+    assert_equal(0, segment_no_time.duration)
+  end
 
-   def test_segment_crop
-      crop_rectangle = GPX::Bounds.new( :min_lat=> 39.173000,
-                                   :min_lon=> -109.010000,
-                                   :max_lat=> 39.188000,
-                                   :max_lon=> -108.999000)
-      @segment.crop(crop_rectangle)
+  def test_segment_crop
+    crop_rectangle = GPX::Bounds.new(min_lat: 39.173000,
+                                     min_lon: -109.010000,
+                                     max_lat: 39.188000,
+                                     max_lon: -108.999000)
+    @segment.crop(crop_rectangle)
 
-      assert_equal(106, @segment.points.size)
-      assert_in_delta(4.11422061733046, @segment.distance, 0.001)
-      assert_equal(1144435041, @segment.earliest_point.time.to_i)
-      assert_equal(1144437752,  @segment.latest_point.time.to_i)
-      assert_equal(1407.027, @segment.lowest_point.elevation)
-      assert_equal(1480.087, @segment.highest_point.elevation)
-      assert_equal(39.173834, @segment.bounds.min_lat)
-      assert_equal(-109.009995, @segment.bounds.min_lon)
-      assert_equal(39.187868,   @segment.bounds.max_lat)
-      assert_equal(-108.999546, @segment.bounds.max_lon)
-      assert_equal(2711.0, @segment.duration)
-   end
+    assert_equal(106, @segment.points.size)
+    assert_in_delta(4.11422061733046, @segment.distance, 0.001)
+    assert_equal(1_144_435_041, @segment.earliest_point.time.to_i)
+    assert_equal(1_144_437_752, @segment.latest_point.time.to_i)
+    assert_equal(1407.027, @segment.lowest_point.elevation)
+    assert_equal(1480.087, @segment.highest_point.elevation)
+    assert_equal(39.173834, @segment.bounds.min_lat)
+    assert_equal(-109.009995, @segment.bounds.min_lon)
+    assert_equal(39.187868,   @segment.bounds.max_lat)
+    assert_equal(-108.999546, @segment.bounds.max_lon)
+    assert_equal(2711.0, @segment.duration)
+  end
 
-   def test_segment_delete
-      delete_rectangle = GPX::Bounds.new( :min_lat=> 39.173000,
-                                   :min_lon=> -109.010000,
-                                   :max_lat=> 39.188000,
-                                   :max_lon=> -108.999000)
-      @segment.delete_area(delete_rectangle)
-      assert_equal(83, @segment.points.size)
-      assert_in_delta(3.35967118153605, @segment.distance, 0.001)
-      assert_equal(1144433525, @segment.earliest_point.time.to_i)
-      assert_equal(1144437991,  @segment.latest_point.time.to_i)
-      assert_equal(1334.447, @segment.lowest_point.elevation)
-      assert_equal(1428.176, @segment.highest_point.elevation)
-      assert_equal(39.180572, @segment.bounds.min_lat)
-      assert_equal(-109.016604, @segment.bounds.min_lon)
-      assert_equal(39.188747,   @segment.bounds.max_lat)
-      assert_equal(-109.007978, @segment.bounds.max_lon)
-      assert_equal(4466.0, @segment.duration)
-   end
+  def test_segment_delete
+    delete_rectangle = GPX::Bounds.new(min_lat: 39.173000,
+                                       min_lon: -109.010000,
+                                       max_lat: 39.188000,
+                                       max_lon: -108.999000)
+    @segment.delete_area(delete_rectangle)
+    assert_equal(83, @segment.points.size)
+    assert_in_delta(3.35967118153605, @segment.distance, 0.001)
+    assert_equal(1_144_433_525, @segment.earliest_point.time.to_i)
+    assert_equal(1_144_437_991, @segment.latest_point.time.to_i)
+    assert_equal(1334.447, @segment.lowest_point.elevation)
+    assert_equal(1428.176, @segment.highest_point.elevation)
+    assert_equal(39.180572, @segment.bounds.min_lat)
+    assert_equal(-109.016604, @segment.bounds.min_lon)
+    assert_equal(39.188747,   @segment.bounds.max_lat)
+    assert_equal(-109.007978, @segment.bounds.max_lon)
+    assert_equal(4466.0, @segment.duration)
+  end
 
-   def test_segment_smooth
-      @segment.smooth_location_by_average
-      assert_equal(189, @segment.points.size)
-      assert_equal(1144433525, @segment.earliest_point.time.to_i)
-      assert_equal(1144437991, @segment.latest_point.time.to_i)
-      assert_equal(1342.58, @segment.lowest_point.elevation)
-      assert_equal(1479.09, @segment.highest_point.elevation)
-      assert_in_delta(6.458085658, @segment.distance, 0.001)
-      assert_equal(4466.0, @segment.duration)
-   end
+  def test_segment_smooth
+    @segment.smooth_location_by_average
+    assert_equal(189, @segment.points.size)
+    assert_equal(1_144_433_525, @segment.earliest_point.time.to_i)
+    assert_equal(1_144_437_991, @segment.latest_point.time.to_i)
+    assert_equal(1342.58, @segment.lowest_point.elevation)
+    assert_equal(1479.09, @segment.highest_point.elevation)
+    assert_in_delta(6.458085658, @segment.distance, 0.001)
+    assert_equal(4466.0, @segment.duration)
+  end
 
-   def test_segment_smooth_offset
-      @segment.smooth_location_by_average({:start => 1000, :end => 2000})
-      assert_equal(189, @segment.points.size)
-      assert_equal(1144433525, @segment.earliest_point.time.to_i)
-      assert_equal(1144437991, @segment.latest_point.time.to_i)
-      assert_equal(1334.447, @segment.lowest_point.elevation)
-      assert_equal(1480.087, @segment.highest_point.elevation)
-      assert_in_delta(6.900813095, @segment.distance, 0.001)
-      assert_equal(4466.0, @segment.duration)
-   end
+  def test_segment_smooth_offset
+    @segment.smooth_location_by_average(start: 1000, end: 2000)
+    assert_equal(189, @segment.points.size)
+    assert_equal(1_144_433_525, @segment.earliest_point.time.to_i)
+    assert_equal(1_144_437_991, @segment.latest_point.time.to_i)
+    assert_equal(1334.447, @segment.lowest_point.elevation)
+    assert_equal(1480.087, @segment.highest_point.elevation)
+    assert_in_delta(6.900813095, @segment.distance, 0.001)
+    assert_equal(4466.0, @segment.duration)
+  end
 
-   def test_segment_smooth_absolute
-      @segment.smooth_location_by_average({:start => Time.at(1144434520), :end => Time.at(1144435520)})
-      assert_equal(189, @segment.points.size)
-      assert_equal(1144433525, @segment.earliest_point.time.to_i)
-      assert_equal(1144437991, @segment.latest_point.time.to_i)
-      assert_equal(1334.447, @segment.lowest_point.elevation)
-      assert_equal(1480.087, @segment.highest_point.elevation)
-      assert_in_delta(6.900813095, @segment.distance, 0.001)
-      assert_equal(4466.0, @segment.duration)
-   end
+  def test_segment_smooth_absolute
+    @segment.smooth_location_by_average(start: Time.at(1_144_434_520), end: Time.at(1_144_435_520))
+    assert_equal(189, @segment.points.size)
+    assert_equal(1_144_433_525, @segment.earliest_point.time.to_i)
+    assert_equal(1_144_437_991, @segment.latest_point.time.to_i)
+    assert_equal(1334.447, @segment.lowest_point.elevation)
+    assert_equal(1480.087, @segment.highest_point.elevation)
+    assert_in_delta(6.900813095, @segment.distance, 0.001)
+    assert_equal(4466.0, @segment.duration)
+  end
 
+  def test_segment_mixed_times
+    gpx_file_mixed_times = GPX::GPXFile.new(gpx_file: ONE_SEGMENT_MIXED_TIMES)
+    segment_mixed_times = gpx_file_mixed_times.tracks.first.segments.first
+    assert_equal(588, segment_mixed_times.points.size)
+    assert_equal(0, segment_mixed_times.earliest_point.time.to_i)
+    assert_equal(0, segment_mixed_times.latest_point.time.to_i)
+    assert_in_delta(40.763726054, segment_mixed_times.distance, 0.001)
+    assert_equal(0.0, segment_mixed_times.duration)
+  end
 end

data/tests/track_file_test.rb

@@ -1,75 +1,55 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'gpx'
 
 class TrackFileTest < Minitest::Test
-   TRACK_FILE = File.join(File.dirname(__FILE__), "gpx_files/tracks.gpx")
-   OTHER_TRACK_FILE = File.join(File.dirname(__FILE__), "gpx_files/arches.gpx")
-
-   def setup
-      @track_file = GPX::GPXFile.new(:gpx_file => TRACK_FILE)
-      @other_track_file = GPX::GPXFile.new(:gpx_file => OTHER_TRACK_FILE)
-   end
-
-   def test_track_read
-      assert_equal(3, @track_file.tracks.size)
-      assert_equal("First Track",  @track_file.tracks[0].name)
-      assert_equal("Second Track", @track_file.tracks[1].name)
-      assert_equal("Third Track",  @track_file.tracks[2].name)
-   end
-
-   def test_track_segment_and_point_counts
-      # One segment with 398 points...
-      assert_equal(1, @track_file.tracks[0].segments.size)
-      assert_equal(389, @track_file.tracks[0].segments.first.points.size)
-
-      # One segment with 299 points...
-      assert_equal(1, @track_file.tracks[1].segments.size)
-      assert_equal(299, @track_file.tracks[1].segments.first.points.size)
-
-      # Many segments of many different sizes
-      segment_sizes = %w{ 2 2 5 4 2 1 197 31 54 1 15 54 19 26 109 18 9 2 8 3 10 23 21 11 25 32 66 21 2 3 3 4 6 4 4 4 3 3 6 6 27 13 2 }
-      assert_equal(43, @track_file.tracks[2].segments.size)
-      @track_file.tracks[2].segments.each_with_index do |seg, i|
-         assert_equal(segment_sizes[i].to_i, seg.points.size)
-      end
-      last_segment = @track_file.tracks[2].segments.last
-      assert_equal(1680.041, last_segment.points.last.elevation)
-
-
-      second_to_last_segment = @track_file.tracks[2].segments[-2]
-      assert_equal("2006-01-02T00:00:51Z", second_to_last_segment.points.last.time.strftime("%Y-%m-%dT%H:%M:%SZ"))
-      assert_equal(39.998045, second_to_last_segment.points.last.lat)
-      assert_equal(-105.292368, second_to_last_segment.points.last.lon)
-   end
-
-   def test_find_nearest_point_by_time
-      time = Time.parse("2005-12-31T22:02:01Z")
-      pt = @track_file.tracks[0].closest_point(time)
-      #puts "pt: #{pt.lat_lon}"
-
-   end
-
-   def test_find_distance
-      #puts "Distance: #{@other_track_file.distance(:units => 'miles')} miles"
-      #puts "Distance: #{@track_file.distance(:units => 'miles')} miles"
-   end
-   def test_high_low_elevation
-      #puts "Lowest: #{@track_file.lowest_point.elevation} m"
-      #puts "Highest: #{@track_file.highest_point.elevation} m"
-   end
-
-   def test_duration
-      #puts "Duration 1: #{@other_track_file.duration} "
-      #puts "Duration 2: #{@track_file.duration} "
-   end
-
-   def test_average_speed
-      #puts "Speed 1: #{@other_track_file.average_speed} "
-      #puts "Speed 2: #{@track_file.average_speed} "
-   end
-
-   def test_write
-      @other_track_file.write("tests/output/myoutput.gpx")
-   end
-
+  TRACK_FILE = File.join(File.dirname(__FILE__), 'gpx_files/tracks.gpx')
+  OTHER_TRACK_FILE = File.join(File.dirname(__FILE__), 'gpx_files/arches.gpx')
+
+  def setup
+    @track_file = GPX::GPXFile.new(gpx_file: TRACK_FILE)
+    @other_track_file = GPX::GPXFile.new(gpx_file: OTHER_TRACK_FILE)
+    FileUtils.mkdir_p(File.join(File.dirname(__FILE__), 'output'))
+  end
+
+  def test_track_read
+    assert_equal(3, @track_file.tracks.size)
+    assert_equal('First Track',  @track_file.tracks[0].name)
+    assert_equal('Second Track', @track_file.tracks[1].name)
+    assert_equal('Third Track',  @track_file.tracks[2].name)
+  end
+
+  def test_track_segment_and_point_counts
+    # One segment with 398 points...
+    assert_equal(1, @track_file.tracks[0].segments.size)
+    assert_equal(389, @track_file.tracks[0].segments.first.points.size)
+
+    # One segment with 299 points...
+    assert_equal(1, @track_file.tracks[1].segments.size)
+    assert_equal(299, @track_file.tracks[1].segments.first.points.size)
+
+    # Many segments of many different sizes
+    segment_sizes = %w[2 2 5 4 2 1 197 31 54 1 15 54 19 26 109 18 9 2 8 3 10 23 21 11 25 32 66 21 2 3 3 4 6 4 4 4 3 3 6 6 27 13 2]
+    assert_equal(43, @track_file.tracks[2].segments.size)
+    @track_file.tracks[2].segments.each_with_index do |seg, i|
+      assert_equal(segment_sizes[i].to_i, seg.points.size)
+    end
+    last_segment = @track_file.tracks[2].segments.last
+    assert_equal(1680.041, last_segment.points.last.elevation)
+
+    second_to_last_segment = @track_file.tracks[2].segments[-2]
+    assert_equal('2006-01-02T00:00:51Z', second_to_last_segment.points.last.time.strftime('%Y-%m-%dT%H:%M:%SZ'))
+    assert_equal(39.998045, second_to_last_segment.points.last.lat)
+    assert_equal(-105.292368, second_to_last_segment.points.last.lon)
+  end
+
+  def test_write
+    output_path = 'tests/output/myoutput.gpx'
+    @other_track_file.write(output_path)
+    new_track_file = GPX::GPXFile.new(gpx_file: output_path)
+    orig_segments = @other_track_file.tracks.first.segments
+    new_segments = new_track_file.tracks.first.segments
+    assert_equal(orig_segments.first.points.map(&:lat_lon), new_segments.first.points.map(&:lat_lon))
+  end
 end

data/tests/track_point_test.rb

@@ -1,16 +1,22 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'gpx'
 
 class TrackPointTest < Minitest::Test
   def setup
-    @point1 = GPX::TrackPoint.new({
-      :lat => 37.7985474,
-      :lon => -122.2554386
-    })
-    @point2 = GPX::TrackPoint.new({
-      :lat => 37.7985583,
-      :lon => -122.2554564
-    })
+    @point1 = GPX::TrackPoint.new(
+      lat: 37.7985474,
+      lon: -122.2554386
+    )
+    @point2 = GPX::TrackPoint.new(
+      lat: 37.7985583,
+      lon: -122.2554564
+    )
+    @point3 = GPX::TrackPoint.new(
+      lat: 38.7985583,
+      lon: -121.2554564
+    )
   end
 
   def test_haversine_distance_from
@@ -18,13 +24,18 @@ class TrackPointTest < Minitest::Test
     assert_in_delta(0.00197862991592239, distance, 1e-18)
   end
 
-  def test_pythagorean_distance_from
-    distance = @point1.pythagorean_distance_from(@point2)
-    assert_equal(3.642891416092969e-07, distance)
+  def test_longer_haversine_distance_from
+    distance = @point2.haversine_distance_from(@point3)
+    assert_in_delta(141.3465338444813, distance, 1e-18)
   end
 
   def test_law_of_cosines_distance_from
     distance = @point1.law_of_cosines_distance_from(@point2)
     assert_equal(0.001982307218559664, distance)
   end
+
+  def test_longer_law_of_cosines_distance_from
+    distance = @point2.law_of_cosines_distance_from(@point3)
+    assert_equal(141.3465338444991, distance)
+  end
 end

data/tests/track_test.rb

@@ -1,72 +1,84 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'gpx'
 
 class TrackTest < Minitest::Test
-   ONE_TRACK = File.join(File.dirname(__FILE__), "gpx_files/one_track.gpx")
+  ONE_TRACK = File.join(File.dirname(__FILE__), 'gpx_files/one_track.gpx')
 
-   def setup
-      @gpx_file = GPX::GPXFile.new(:gpx_file => ONE_TRACK)
-      @track = @gpx_file.tracks.first
-   end
+  def setup
+    @gpx_file = GPX::GPXFile.new(gpx_file: ONE_TRACK)
+    @track = @gpx_file.tracks.first
+  end
 
-   def test_track_read
-      assert_equal("ACTIVE LOG", @track.name)
-      assert_equal("Comment Log", @track.comment)
-      assert_equal("Description Log", @track.description)
-      assert_equal( 182, @track.points.size)
-      assert_equal(8, @track.segments.size)
-      assert_in_delta(3.07249668492626, @track.distance, 0.001)
-      assert_equal(1267.155, @track.lowest_point.elevation)
-      assert_equal(1594.003, @track.highest_point.elevation)
-      assert_equal(38.681488, @track.bounds.min_lat)
-      assert_equal(-109.606948, @track.bounds.min_lon)
-      assert_equal(38.791759, @track.bounds.max_lat)
-      assert_equal(-109.447045, @track.bounds.max_lon)
-      assert_equal(3036.0,  @track.moving_duration)
-   end
+  def test_track_read
+    assert_equal('ACTIVE LOG', @track.name)
+    assert_equal('Comment Log', @track.comment)
+    assert_equal('Description Log', @track.description)
+    assert_equal(182, @track.points.size)
+    assert_equal(8, @track.segments.size)
+    assert_in_delta(3.07249668492626, @track.distance, 0.001)
+    assert_equal(1267.155, @track.lowest_point.elevation)
+    assert_equal(1594.003, @track.highest_point.elevation)
+    assert_equal(38.681488, @track.bounds.min_lat)
+    assert_equal(-109.606948, @track.bounds.min_lon)
+    assert_equal(38.791759, @track.bounds.max_lat)
+    assert_equal(-109.447045, @track.bounds.max_lon)
+    assert_equal(3036.0, @track.moving_duration)
+  end
 
-   def test_track_crop
-      area = GPX::Bounds.new(
-         :min_lat =>   38.710000,
-         :min_lon => -109.600000,
-         :max_lat =>   38.791759,
-         :max_lon => -109.450000)
-      @track.crop(area)
-      assert_equal("ACTIVE LOG", @track.name)
-      assert_equal("Comment Log", @track.comment)
-      assert_equal("Description Log", @track.description)
-      assert_equal( 111, @track.points.size)
-      assert_equal(4, @track.segments.size)
-      assert_in_delta(1.62136024923607, @track.distance, 0.001)
-      assert_equal(1557.954, @track.lowest_point.elevation)
-      assert_equal(1582.468, @track.highest_point.elevation)
-      assert_equal(38.782511, @track.bounds.min_lat)
-      assert_equal(-109.599781, @track.bounds.min_lon)
-      assert_equal(38.789527, @track.bounds.max_lat)
-      assert_equal(-109.594996, @track.bounds.max_lon)
-      assert_equal(1773.0,  @track.moving_duration)
-   end
+  def test_track_crop
+    area = GPX::Bounds.new(
+      min_lat: 38.710000,
+      min_lon: -109.600000,
+      max_lat: 38.791759,
+      max_lon: -109.450000
+    )
+    @track.crop(area)
+    assert_equal('ACTIVE LOG', @track.name)
+    assert_equal('Comment Log', @track.comment)
+    assert_equal('Description Log', @track.description)
+    assert_equal(111, @track.points.size)
+    assert_equal(4, @track.segments.size)
+    assert_in_delta(1.62136024923607, @track.distance, 0.001)
+    assert_equal(1557.954, @track.lowest_point.elevation)
+    assert_equal(1582.468, @track.highest_point.elevation)
+    assert_equal(38.782511, @track.bounds.min_lat)
+    assert_equal(-109.599781, @track.bounds.min_lon)
+    assert_equal(38.789527, @track.bounds.max_lat)
+    assert_equal(-109.594996, @track.bounds.max_lon)
+    assert_equal(1773.0, @track.moving_duration)
+  end
 
-   def test_track_delete
-      area = GPX::Bounds.new(
-         :min_lat =>   38.710000,
-         :min_lon => -109.600000,
-         :max_lat =>   38.791759,
-         :max_lon => -109.450000)
-      @track.delete_area(area)
+  def test_track_delete
+    area = GPX::Bounds.new(
+      min_lat: 38.710000,
+      min_lon: -109.600000,
+      max_lat: 38.791759,
+      max_lon: -109.450000
+    )
+    @track.delete_area(area)
 
-      assert_equal(1229.0,  @track.moving_duration)
-      #puts @track
-      assert_equal("ACTIVE LOG", @track.name)
-      assert_equal(71, @track.points.size)
-      assert_equal(6, @track.segments.size)
-      assert_in_delta(1.197905851972874, @track.distance, 0.00000000001)
-      assert_equal(1267.155, @track.lowest_point.elevation)
-      assert_equal(1594.003, @track.highest_point.elevation)
-      assert_equal(38.681488, @track.bounds.min_lat)
-      assert_equal(-109.606948, @track.bounds.min_lon)
-      assert_equal(38.791759, @track.bounds.max_lat)
-      assert_equal(-109.447045, @track.bounds.max_lon)
-   end
+    assert_equal(1229.0, @track.moving_duration)
+    # puts @track
+    assert_equal('ACTIVE LOG', @track.name)
+    assert_equal(71, @track.points.size)
+    assert_equal(6, @track.segments.size)
+    assert_in_delta(1.197905851972874, @track.distance, 0.00000000001)
+    assert_equal(1267.155, @track.lowest_point.elevation)
+    assert_equal(1594.003, @track.highest_point.elevation)
+    assert_equal(38.681488, @track.bounds.min_lat)
+    assert_equal(-109.606948, @track.bounds.min_lon)
+    assert_equal(38.791759, @track.bounds.max_lat)
+    assert_equal(-109.447045, @track.bounds.max_lon)
+  end
 
+  def test_append_segment
+    trk = GPX::Track.new
+    seg = GPX::Segment.new(track: trk)
+    pt = GPX::TrackPoint.new(lat: -118, lon: 34)
+    seg.append_point(pt)
+    trk.append_segment(seg)
+    assert_equal(1, trk.points.size)
+  end
 end

data/tests/waypoint_test.rb

@@ -1,48 +1,46 @@
-require 'minitest/autorun'
-require 'gpx'
-
-class WaypointTest < Minitest::Test
-
-  def test_read_waypoints
-
-    gpx = GPX::GPXFile.new(:gpx_file => File.join(File.dirname(__FILE__), "gpx_files/waypoints.gpx"))
-    assert_equal(18, gpx.waypoints.size)
-
-    #    First Waypoint
-    #   <wpt lat="40.035557" lon="-105.248268">
-    #   <name><![CDATA[001]]></name>
-    #   <sym>Waypoint</sym>
-    #   <ele>1639.161</ele>
-    #   <cmt><![CDATA[001]]></cmt>
-    #   <desc><![CDATA[Just some waypoint...]]></desc>
-    #   </wpt>
-
-    first_wpt = gpx.waypoints[0]
-    assert_equal(40.035557, first_wpt.lat)
-    assert_equal(-105.248268, first_wpt.lon)
-    assert_equal('001', first_wpt.name)
-    assert_equal('001', first_wpt.cmt)
-    assert_equal('Just some waypoint...', first_wpt.desc)
-    assert_equal('Waypoint', first_wpt.sym)
-  	assert_equal(1639.161, first_wpt.elevation)
-
-    #    Second Waypoint
-    #    <wpt lat="39.993070" lon="-105.296588">
-    #    <name><![CDATA[002]]></name>
-    #    <sym>Waypoint</sym>
-    #    <ele>1955.192</ele>
-    #    </wpt>
-    second_wpt = gpx.waypoints[1]
-    assert_equal(39.993070, second_wpt.lat)
-    assert_equal(-105.296588, second_wpt.lon)
-    assert_equal('002', second_wpt.name)
-    assert_equal('Waypoint', second_wpt.sym)
-    assert_equal(1955.192, second_wpt.elevation)
-    
-    # test loads time properly in waypoint
-    time_wpt = gpx.waypoints[17]
-    assert_equal(Time.xmlschema("2015-01-01T12:12:12Z"), time_wpt.time)
-    
-  end
-end
-
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'gpx'
+
+class WaypointTest < Minitest::Test
+  def test_read_waypoints
+    gpx = GPX::GPXFile.new(gpx_file: File.join(File.dirname(__FILE__), 'gpx_files/waypoints.gpx'))
+    assert_equal(18, gpx.waypoints.size)
+
+    #    First Waypoint
+    #   <wpt lat="40.035557" lon="-105.248268">
+    #   <name><![CDATA[001]]></name>
+    #   <sym>Waypoint</sym>
+    #   <ele>1639.161</ele>
+    #   <cmt><![CDATA[001]]></cmt>
+    #   <desc><![CDATA[Just some waypoint...]]></desc>
+    #   </wpt>
+
+    first_wpt = gpx.waypoints[0]
+    assert_equal(40.035557, first_wpt.lat)
+    assert_equal(-105.248268, first_wpt.lon)
+    assert_equal('001', first_wpt.name)
+    assert_equal('001', first_wpt.cmt)
+    assert_equal('Just some waypoint...', first_wpt.desc)
+    assert_equal('Waypoint', first_wpt.sym)
+    assert_equal(1639.161, first_wpt.elevation)
+
+    #    Second Waypoint
+    #    <wpt lat="39.993070" lon="-105.296588">
+    #    <name><![CDATA[002]]></name>
+    #    <sym>Waypoint</sym>
+    #    <ele>1955.192</ele>
+    #    </wpt>
+    second_wpt = gpx.waypoints[1]
+    assert_equal(39.993070, second_wpt.lat)
+    assert_equal(-105.296588, second_wpt.lon)
+    assert_equal('002', second_wpt.name)
+    assert_equal('Waypoint', second_wpt.sym)
+    assert_equal(1955.192, second_wpt.elevation)
+
+    # test loads time properly in waypoint
+    time_wpt = gpx.waypoints[17]
+    assert_equal(Time.xmlschema('2015-01-01T12:12:12Z'), time_wpt.time)
+  end
+end