cosmos 3.2.1 → 3.3.0

data/spec/core_ext/stringio_spec.rb

@@ -14,8 +14,8 @@ require 'cosmos/core_ext/stringio'
 describe StringIO do
 
   describe "path" do
-    it "should return nil" do
-      StringIO.new.path.should be_nil
+    it "returns nil" do
+      expect(StringIO.new.path).to be_nil
     end
   end
 end

data/spec/core_ext/time_spec.rb

@@ -14,76 +14,76 @@ require 'cosmos/core_ext/time'
 describe Time do
 
   describe "CONSTANTS" do
-    it "should be correct" do
-      Time::JULIAN_DATE_OF_MJD_EPOCH.should eql DateTime.new(1858,11,17).ajd.to_f
-      Time::JULIAN_DATE_OF_GPS_EPOCH.should eql DateTime.new(1980,1,06).ajd.to_f
-      Time::JULIAN_DATE_OF_J2000_EPOCH.should eql DateTime.new(2000,1,1,12).ajd.to_f
-      Time::JULIAN_DATE_OF_CCSDS_EPOCH.should eql DateTime.new(1958,1,1).ajd.to_f
+    it "is correct" do
+      expect(Time::JULIAN_DATE_OF_MJD_EPOCH).to eql DateTime.new(1858,11,17).ajd.to_f
+      expect(Time::JULIAN_DATE_OF_GPS_EPOCH).to eql DateTime.new(1980,1,06).ajd.to_f
+      expect(Time::JULIAN_DATE_OF_J2000_EPOCH).to eql DateTime.new(2000,1,1,12).ajd.to_f
+      expect(Time::JULIAN_DATE_OF_CCSDS_EPOCH).to eql DateTime.new(1958,1,1).ajd.to_f
     end
   end
 
   describe "Time.format_seconds" do
-    it "should convert a Time to human readable format" do
-      Time.format_seconds(1).should eql "1.00 seconds"
-      Time.format_seconds(1.2345).should eql "1.23 seconds"
-      Time.format_seconds(60).should eql "1 minute"
-      Time.format_seconds(121).should eql "2 minutes, 1.00 seconds"
-      Time.format_seconds(3600).should eql "1 hour"
-      Time.format_seconds(7201).should eql "2 hours, 1.00 seconds"
-      Time.format_seconds(7261).should eql "2 hours, 1 minute, 1.00 seconds"
-      Time.format_seconds(3600*24).should eql "1 day"
-      Time.format_seconds(3600*24+1).should eql "1 day, 1.00 seconds"
-      Time.format_seconds(3600*48+61).should eql "2 days, 1 minute, 1.00 seconds"
-      Time.format_seconds(3600*25+61).should eql "1 day, 1 hour, 1 minute, 1.00 seconds"
+    it "converts a Time to human readable format" do
+      expect(Time.format_seconds(1)).to eql "1.00 seconds"
+      expect(Time.format_seconds(1.2345)).to eql "1.23 seconds"
+      expect(Time.format_seconds(60)).to eql "1 minute"
+      expect(Time.format_seconds(121)).to eql "2 minutes, 1.00 seconds"
+      expect(Time.format_seconds(3600)).to eql "1 hour"
+      expect(Time.format_seconds(7201)).to eql "2 hours, 1.00 seconds"
+      expect(Time.format_seconds(7261)).to eql "2 hours, 1 minute, 1.00 seconds"
+      expect(Time.format_seconds(3600*24)).to eql "1 day"
+      expect(Time.format_seconds(3600*24+1)).to eql "1 day, 1.00 seconds"
+      expect(Time.format_seconds(3600*48+61)).to eql "2 days, 1 minute, 1.00 seconds"
+      expect(Time.format_seconds(3600*25+61)).to eql "1 day, 1 hour, 1 minute, 1.00 seconds"
     end
   end
 
   describe "Time.mdy2julian" do
-    it "should convert year, month, day into a julian date" do
-      Time.mdy2julian(1858, 11, 17).should eql Time::JULIAN_DATE_OF_MJD_EPOCH
+    it "converts year, month, day into a julian date" do
+      expect(Time.mdy2julian(1858, 11, 17)).to eql Time::JULIAN_DATE_OF_MJD_EPOCH
     end
   end
 
   describe "to_julian" do
-    it "should convert a Time into a julian date" do
-      Time.new(1858, 11, 17).to_julian.should eql Time::JULIAN_DATE_OF_MJD_EPOCH
+    it "converts a Time into a julian date" do
+      expect(Time.new(1858, 11, 17).to_julian).to eql Time::JULIAN_DATE_OF_MJD_EPOCH
     end
   end
 
   describe "Time.mdy2mjd" do
-    it "should convert year, month, day into a modified julian date" do
-      Time.mdy2mjd(1858, 11, 17).should eql 0.0
+    it "converts year, month, day into a modified julian date" do
+      expect(Time.mdy2mjd(1858, 11, 17)).to eql 0.0
     end
   end
 
   describe "to_mjd" do
-    it "should convert a Time into a modified julian date" do
-      Time.new(1858, 11, 17).to_mjd.should eql 0.0
+    it "converts a Time into a modified julian date" do
+      expect(Time.new(1858, 11, 17).to_mjd).to eql 0.0
     end
   end
 
   describe "Time.yds" do
-    it "should create a time based on year, date of year, seconds" do
+    it "creates a time based on year, date of year, seconds" do
       time = Time.yds(2020, 1, 1)
-      time.year.should eql 2020
-      time.month.should eql 1
-      time.day.should eql 1
-      time.hour.should eql 0
-      time.min.should eql 0
-      time.sec.should eql 1
+      expect(time.year).to eql 2020
+      expect(time.month).to eql 1
+      expect(time.day).to eql 1
+      expect(time.hour).to eql 0
+      expect(time.min).to eql 0
+      expect(time.sec).to eql 1
 
       time = Time.yds(2020, 366, 7261)
-      time.year.should eql 2020
-      time.month.should eql 12
-      time.day.should eql 31
-      time.hour.should eql 2
-      time.min.should eql 1
-      time.sec.should eql 1
+      expect(time.year).to eql 2020
+      expect(time.month).to eql 12
+      expect(time.day).to eql 31
+      expect(time.hour).to eql 2
+      expect(time.min).to eql 1
+      expect(time.sec).to eql 1
     end
   end
 
   describe "Time.leap_year?" do
-    it "should return true for a leap year" do
+    it "returns true for a leap year" do
       expect(Time.leap_year?(2020)).to be true
       expect(Time.leap_year?(2021)).to be false
     end
@@ -96,107 +96,107 @@ describe Time do
   end
 
   describe "Time.total_seconds" do
-    it "should return the seconds based on hours, minutes, seconds, us" do
-      Time.total_seconds(0,0,0,1000).should eql 0.001
-      Time.total_seconds(0,0,1,1000000).should eql 2.0
-      Time.total_seconds(0,0,61,0).should eql 61.0
-      Time.total_seconds(0,1,61,0).should eql 121.0
-      Time.total_seconds(1,1,61,0).should eql 3721.0
-      Time.total_seconds(25,0,0,0).should eql 90000.0
+    it "returns the seconds based on hours, minutes, seconds, us" do
+      expect(Time.total_seconds(0,0,0,1000)).to eql 0.001
+      expect(Time.total_seconds(0,0,1,1000000)).to eql 2.0
+      expect(Time.total_seconds(0,0,61,0)).to eql 61.0
+      expect(Time.total_seconds(0,1,61,0)).to eql 121.0
+      expect(Time.total_seconds(1,1,61,0)).to eql 3721.0
+      expect(Time.total_seconds(25,0,0,0)).to eql 90000.0
     end
   end
 
   describe "seconds_of_day" do
-    it "should return the seconds in the day" do
-      Time.new(2020,1,1,1,1,1).seconds_of_day.should eql 3661.0
+    it "returns the seconds in the day" do
+      expect(Time.new(2020,1,1,1,1,1).seconds_of_day).to eql 3661.0
     end
   end
 
   describe "formatted" do
-    it "should format the Time" do
-      Time.new(2020,1,2,3,4,5.5).formatted.should eql "2020/01/02 03:04:05.500"
+    it "formats the Time" do
+      expect(Time.new(2020,1,2,3,4,5.5).formatted).to eql "2020/01/02 03:04:05.500"
     end
 
-    it "should format the Time without the date" do
-      Time.new(2020,1,2,3,4,5.5).formatted(false).should eql "03:04:05.500"
+    it "formats the Time without the date" do
+      expect(Time.new(2020,1,2,3,4,5.5).formatted(false)).to eql "03:04:05.500"
     end
   end
 
   describe "Time.days_from_j2000" do
-    it "should return the number of days since J2000" do
-      Time.days_from_j2000(Time.new(2000,1,1,12)).should eql 0.0
-      Time.days_from_j2000(Time.new(2000,1,2,12)).should eql 1.0
+    it "returns the number of days since J2000" do
+      expect(Time.days_from_j2000(Time.new(2000,1,1,12))).to eql 0.0
+      expect(Time.days_from_j2000(Time.new(2000,1,2,12))).to eql 1.0
     end
   end
 
   describe "Time.julian_centuries_since_j2000" do
-    it "should return the number of centuries since J2000" do
-      Time.julian_centuries_since_j2000(Time.new(2100,1,1,12)).should eql 1.0
+    it "returns the number of centuries since J2000" do
+      expect(Time.julian_centuries_since_j2000(Time.new(2100,1,1,12))).to eql 1.0
     end
   end
 
   describe "Time.julian2mdy" do
-    it "should return the YMD from a Julian date" do
+    it "returns the YMD from a Julian date" do
       # Result generated from aa.usno.navy.mil/data/docs/JulianDate.php
       # Ignore the seconds value
-      Time.julian2mdy(2457024.627836)[0..-2].should eql [2015,1,2,3,4,5]
+      expect(Time.julian2mdy(2457024.627836)[0..-2]).to eql [2015,1,2,3,4,5]
       # Ignore the seconds value
-      Time.julian2mdy(2369916.021181)[0..-2].should eql [1776,7,4,12,30,30]
+      expect(Time.julian2mdy(2369916.021181)[0..-2]).to eql [1776,7,4,12,30,30]
     end
   end
 
   describe "Time.ccsds2mdy and Time.mdy2ccsds" do
-    it "should convert YMD to and from CCSDS" do
-      Time.ccsds2mdy(0, 1000, 2).should eql [1958,1,1,0,0,1,2]
+    it "converts YMD to and from CCSDS" do
+      expect(Time.ccsds2mdy(0, 1000, 2)).to eql [1958,1,1,0,0,1,2]
       ccsds_day, ccsds_ms, ccsds_us = Time.mdy2ccsds(2015,1,2,3,4,5,6)
-      Time.ccsds2mdy(ccsds_day, ccsds_ms, ccsds_us).should eql [2015,1,2,3,4,5,6]
+      expect(Time.ccsds2mdy(ccsds_day, ccsds_ms, ccsds_us)).to eql [2015,1,2,3,4,5,6]
     end
   end
 
   describe "Time.ccsds2julian and Time.julian2ccsds" do
-    it "should convert CCSDS to and from Julian" do
-      Time.ccsds2julian(0, 1000, 2).should be_within(0.00001).of(2436204.500012)
+    it "converts CCSDS to and from Julian" do
+      expect(Time.ccsds2julian(0, 1000, 2)).to be_within(0.00001).of(2436204.500012)
       time = Time.now
       ccsds_day, ccsds_ms, ccsds_us = Time.mdy2ccsds(2015,1,2,3,4,5,100)
       julian = Time.ccsds2julian(ccsds_day, ccsds_ms, ccsds_us)
       parts = Time.julian2ccsds(julian)
-      parts[0].should eql ccsds_day
-      parts[1].should eql ccsds_ms
-      parts[2].should be_within(50).of(ccsds_us)
+      expect(parts[0]).to eql ccsds_day
+      expect(parts[1]).to eql ccsds_ms
+      expect(parts[2]).to be_within(50).of(ccsds_us)
     end
   end
 
   describe "Time.ccsds2sec and Time.sec2ccsds" do
-    it "should convert seconds to and from CCSDS" do
-      Time.ccsds2sec(0, 1000, 2).should be_within(0.00001).of(1)
+    it "converts seconds to and from CCSDS" do
+      expect(Time.ccsds2sec(0, 1000, 2)).to be_within(0.00001).of(1)
       time = Time.now
       ccsds_day, ccsds_ms, ccsds_us = Time.mdy2ccsds(2015,1,2,3,4,5,100)
       seconds = Time.ccsds2sec(ccsds_day, ccsds_ms, ccsds_us)
       parts = Time.sec2ccsds(seconds)
-      parts[0].should eql ccsds_day
-      parts[1].should eql ccsds_ms
-      parts[2].should be_within(50).of(ccsds_us)
+      expect(parts[0]).to eql ccsds_day
+      expect(parts[1]).to eql ccsds_ms
+      expect(parts[2]).to be_within(50).of(ccsds_us)
     end
   end
 
   describe "Time.yds2mdy" do
-    it "should convert year, day, seconds" do
-      Time.yds2mdy(2020, 1, 1.5).should eql [2020,1,1,0,0,1,500000]
-      Time.yds2mdy(2020, 60, 3661.5).should eql [2020,2,29,1,1,1,500000]
-      Time.yds2mdy(2021, 60, 3661.5).should eql [2021,3,1,1,1,1,500000]
+    it "converts year, day, seconds" do
+      expect(Time.yds2mdy(2020, 1, 1.5)).to eql [2020,1,1,0,0,1,500000]
+      expect(Time.yds2mdy(2020, 60, 3661.5)).to eql [2020,2,29,1,1,1,500000]
+      expect(Time.yds2mdy(2021, 60, 3661.5)).to eql [2021,3,1,1,1,1,500000]
     end
   end
 
   describe "Time.yds2julian" do
-    it "should convert year, day, seconds to julian" do
-      Time.yds2julian(2000,1,12*60*60).should eql Time::JULIAN_DATE_OF_J2000_EPOCH
+    it "converts year, day, seconds to julian" do
+      expect(Time.yds2julian(2000,1,12*60*60)).to eql Time::JULIAN_DATE_OF_J2000_EPOCH
     end
   end
 
   describe "Time.unix_epoch_delta" do
-    it "should return a delta to the unix epoch" do
-      Time.init_epoch_delta("1970/01/01 00:00:00").should eql 0
-      Time.init_epoch_delta("1969/12/31 12:00:00").should eql 60*60*12
+    it "returns a delta to the unix epoch" do
+      expect(Time.init_epoch_delta("1970/01/01 00:00:00")).to eql 0
+      expect(Time.init_epoch_delta("1969/12/31 12:00:00")).to eql 60*60*12
     end
   end
 end

data/spec/gui/line_graph/line_clip_spec.rb

@@ -16,74 +16,74 @@ module Cosmos
   describe LineClip do
 
     shared_examples_for "line returned" do
-      it "should not be nil" do
-        @clipped_line.should_not be_nil
+      it "is not nil" do
+        expect(@clipped_line).not_to be_nil
       end
     end
 
     shared_examples_for "no line returned" do
-      it "should be nil" do
-        @clipped_line.should be_nil
+      it "is nil" do
+        expect(@clipped_line).to be_nil
       end
     end
 
     shared_examples_for "not clipped" do
-      it "should return the same first point" do
-        @clipped_line[0].should eql(@x0)
-        @clipped_line[1].should eql(@y0)
+      it "returns the same first point" do
+        expect(@clipped_line[0]).to eql(@x0)
+        expect(@clipped_line[1]).to eql(@y0)
       end
 
-      it "should return the same second point" do
-        @clipped_line[2].should eql(@x1)
-        @clipped_line[3].should eql(@y1)
+      it "returns the same second point" do
+        expect(@clipped_line[2]).to eql(@x1)
+        expect(@clipped_line[3]).to eql(@y1)
       end
 
-      it "should indicate the first point was not clipped" do
-        @clipped_line[4].should be_falsey
+      it "indicates the first point was not clipped" do
+        expect(@clipped_line[4]).to be_falsey
       end
 
-      it "should indicate the second point was not clipped" do
-        @clipped_line[5].should be_falsey
+      it "indicates the second point was not clipped" do
+        expect(@clipped_line[5]).to be_falsey
       end
     end
 
     shared_examples_for "first point clipped" do
-      it "should return a clipped first point" do
-        (@xmin..@xmax).should include(@clipped_line[0])
-        (@ymin..@ymax).should include(@clipped_line[1])
+      it "returns a clipped first point" do
+        expect(@xmin..@xmax).to include(@clipped_line[0])
+        expect(@ymin..@ymax).to include(@clipped_line[1])
       end
 
-      it "should return the same second point" do
-        @clipped_line[2].should eql(@x1)
-        @clipped_line[3].should eql(@y1)
+      it "returns the same second point" do
+        expect(@clipped_line[2]).to eql(@x1)
+        expect(@clipped_line[3]).to eql(@y1)
       end
 
-      it "should indicate the first point was clipped" do
-        @clipped_line[4].should be_truthy
+      it "indicates the first point was clipped" do
+        expect(@clipped_line[4]).to be_truthy
       end
 
-      it "should indicate the second point was not clipped" do
-        @clipped_line[5].should be_falsey
+      it "indicates the second point was not clipped" do
+        expect(@clipped_line[5]).to be_falsey
       end
     end
 
     shared_examples_for "second point clipped" do
-      it "should return the same first point" do
-        @clipped_line[0].should eql(@x0)
-        @clipped_line[1].should eql(@y0)
+      it "returns the same first point" do
+        expect(@clipped_line[0]).to eql(@x0)
+        expect(@clipped_line[1]).to eql(@y0)
       end
 
-      it "should return a clipped second point" do
-        (@xmin..@xmax).should include(@clipped_line[2])
-        (@ymin..@ymax).should include(@clipped_line[3])
+      it "returns a clipped second point" do
+        expect(@xmin..@xmax).to include(@clipped_line[2])
+        expect(@ymin..@ymax).to include(@clipped_line[3])
       end
 
-      it "should indicate the first point was not clipped" do
-        @clipped_line[4].should be_falsey
+      it "indicates the first point was not clipped" do
+        expect(@clipped_line[4]).to be_falsey
       end
 
-      it "should indicate the second point was clipped" do
-        @clipped_line[5].should be_truthy
+      it "indicates the second point was clipped" do
+        expect(@clipped_line[5]).to be_truthy
       end
     end
 

data/spec/interfaces/interface_spec.rb

@@ -16,36 +16,36 @@ module Cosmos
   describe Interface do
 
     describe "include API" do
-      it "should include API" do
-        Interface.new.methods.should include :cmd
+      it "includes API" do
+        expect(Interface.new.methods).to include :cmd
       end
     end
 
     describe "initialize" do
-      it "should initialize the instance variables" do
+      it "initializes the instance variables" do
         i = Interface.new
-        i.name.should eql "Cosmos::Interface"
-        i.target_names.should eql []
-        i.thread.should be_nil
-        i.connect_on_startup.should be_truthy
-        i.auto_reconnect.should be_truthy
-        i.reconnect_delay.should eql 5.0
-        i.disable_disconnect.should be_falsey
-        i.packet_log_writer_pairs.should eql []
-        i.routers.should eql []
-        i.read_count.should eql 0
-        i.write_count.should eql 0
-        i.bytes_read.should eql 0
-        i.bytes_written.should eql 0
-        i.num_clients.should eql 0
-        i.read_queue_size.should eql 0
-        i.write_queue_size.should eql 0
-        i.interfaces.should eql []
+        expect(i.name).to eql "Cosmos::Interface"
+        expect(i.target_names).to eql []
+        expect(i.thread).to be_nil
+        expect(i.connect_on_startup).to be_truthy
+        expect(i.auto_reconnect).to be_truthy
+        expect(i.reconnect_delay).to eql 5.0
+        expect(i.disable_disconnect).to be_falsey
+        expect(i.packet_log_writer_pairs).to eql []
+        expect(i.routers).to eql []
+        expect(i.read_count).to eql 0
+        expect(i.write_count).to eql 0
+        expect(i.bytes_read).to eql 0
+        expect(i.bytes_written).to eql 0
+        expect(i.num_clients).to eql 0
+        expect(i.read_queue_size).to eql 0
+        expect(i.write_queue_size).to eql 0
+        expect(i.interfaces).to eql []
       end
     end
 
     describe "virtual methods" do
-      it "should raise an error" do
+      it "raises an error" do
         i = Interface.new
         expect { i.connect }.to raise_error(/connect method not implemented/)
         expect { i.connected? }.to raise_error(/connected\? method not implemented/)
@@ -57,25 +57,25 @@ module Cosmos
     end
 
     describe "read_allowed?" do
-      it "should be true" do
-        Interface.new.read_allowed?.should be_truthy
+      it "is true" do
+        expect(Interface.new.read_allowed?).to be_truthy
       end
     end
 
     describe "write_allowed?" do
-      it "should be true" do
-        Interface.new.write_allowed?.should be_truthy
+      it "is true" do
+        expect(Interface.new.write_allowed?).to be_truthy
       end
     end
 
     describe "write_raw_allowed?" do
-      it "should be true" do
-        Interface.new.write_raw_allowed?.should be_truthy
+      it "is true" do
+        expect(Interface.new.write_raw_allowed?).to be_truthy
       end
     end
 
     describe "copy_to" do
-      it "should copy the interface" do
+      it "copies the interface" do
         i = Interface.new
         i.name = 'TEST'
         i.target_names = ['TGT1','TGT2']
@@ -97,30 +97,30 @@ module Cosmos
 
         i2 = Interface.new
         i.copy_to(i2)
-        i2.name.should eql 'TEST'
-        i2.target_names.should eql ['TGT1','TGT2']
-        i2.thread.should be_nil # Thread does not get copied
-        i2.connect_on_startup.should be_falsey
-        i2.auto_reconnect.should be_falsey
-        i2.reconnect_delay.should eql 1.0
-        i2.disable_disconnect.should be_truthy
-        i2.packet_log_writer_pairs.should eql [1,2]
-        i2.routers.should eql [3,4]
-        i2.read_count.should eql 1
-        i2.write_count.should eql 2
-        i2.bytes_read.should eql 3
-        i2.bytes_written.should eql 4
-        i2.num_clients.should eql 0 # does not get copied
-        i2.read_queue_size.should eql 0 # does not get copied
-        i2.write_queue_size.should eql 0 # does not get copied
-        i2.interfaces.should eql [5,6]
+        expect(i2.name).to eql 'TEST'
+        expect(i2.target_names).to eql ['TGT1','TGT2']
+        expect(i2.thread).to be_nil # Thread does not get copied
+        expect(i2.connect_on_startup).to be_falsey
+        expect(i2.auto_reconnect).to be_falsey
+        expect(i2.reconnect_delay).to eql 1.0
+        expect(i2.disable_disconnect).to be_truthy
+        expect(i2.packet_log_writer_pairs).to eql [1,2]
+        expect(i2.routers).to eql [3,4]
+        expect(i2.read_count).to eql 1
+        expect(i2.write_count).to eql 2
+        expect(i2.bytes_read).to eql 3
+        expect(i2.bytes_written).to eql 4
+        expect(i2.num_clients).to eql 0 # does not get copied
+        expect(i2.read_queue_size).to eql 0 # does not get copied
+        expect(i2.write_queue_size).to eql 0 # does not get copied
+        expect(i2.interfaces).to eql [5,6]
 
         Cosmos.kill_thread(nil, i.thread)
       end
     end
 
     describe "post_identify_packet" do
-      it "should do nothing" do
+      it "does nothing" do
         expect { Interface.new.post_identify_packet(nil) }.to_not raise_error
       end
     end