cosmos 3.8.2 → 3.8.3

data/lib/cosmos/tools/table_manager/table_manager_core.rb

@@ -102,7 +102,7 @@ module Cosmos
       ensure
         reset()
       end
-      return bin_files
+      bin_files
     end
 
     # Opens a specified binary file using a specified definition file as the interpreter
@@ -143,8 +143,7 @@ module Cosmos
           result << "Error(s) in #{table.name}:\n" + table_result
         end
       end
-
-      return result
+      result
     end
 
     def file_hex
@@ -156,10 +155,7 @@ module Cosmos
         data << table.buffer
       end
 
-      str, size = create_hex_string(data)
-      str << "\n\nTotal Bytes Read: %d" % size
-
-      return str
+      "#{data.formatted}\n\nTotal Bytes Read: #{data.length}"
     end
 
     # Generate the RPT file for the currently opened file
@@ -304,31 +300,31 @@ module Cosmos
           end
 
           x = table.read(item_def.name, :RAW)
+          if item_def.data_type == :STRING
+            if x.length > item_def.bit_size / 8
+              result << "  #{item_def.name}: #{x} must be less than #{item_def.bit_size / 8} characters\n"
+            end
+          end
+
           unless item_def.range.nil?
-            if item_def.display_type == :STRING
-              if x.length > item_def.range.last || x.length < item_def.range.first
-                result << "  #{item_def.name}: #{x} must be between #{item_def.range.first} and #{item_def.range.last} characters\n"
-              end
-            else
-              # check to see if the value lies within its valid range
-              if not item_def.range.include?(x)
-                # if the value is displayed as hex, display the range as hex
-                if item_def.display_type == :HEX
-                  range_first = "0x%X" % item_def.range.first
-                  range_last = "0x%X" % item_def.range.last
-                  x = "0x%X" % x
-                else
-                  range_first = item_def.range.first
-                  range_last = item_def.range.last
-                  x = table.read(item_def.name)
-                end
-                result << "  #{item_def.name}: #{x} outside valid range of #{range_first}..#{range_last}\n"
+            # check to see if the value lies within its valid range
+            if not item_def.range.include?(x)
+              # if the value is displayed as hex, display the range as hex
+              if item_def.display_type == :HEX
+                range_first = "0x%X" % item_def.range.first
+                range_last = "0x%X" % item_def.range.last
+                x = "0x%X" % x
+              else
+                range_first = item_def.range.first
+                range_last = item_def.range.last
+                x = table.read(item_def.name)
               end
+              result << "  #{item_def.name}: #{x} outside valid range of #{range_first}..#{range_last}\n"
             end
           end
         end # end each column
       end # end each row
-      return result
+      result
     end
 
     def table_default(table_name)
@@ -342,11 +338,7 @@ module Cosmos
       table = @table_def.get_table(table_name)
       raise "Please open a table first." unless table
 
-      data = table.buffer
-      str, size = create_hex_string(data)
-      str << "\n\nTotal Bytes Read: %d" % size
-
-      return str
+      "#{table.buffer.formatted}\n\nTotal Bytes Read: #{table.buffer.length}"
     end
 
     # option to save the currently displayed table as a stand alone binary file
@@ -442,7 +434,6 @@ module Cosmos
     # Override on_save to perform additional actions before the file is
     # saved to disk.
     def on_save
-      return
     end
 
     # Determines the string representation of an item as it should be printed in a RPT file
@@ -463,30 +454,7 @@ module Cosmos
       when :HEX
         result = @table_def.format_hex(table, item_def)
       end
-
-      return result
-    end
-
-    # Create a hex string representation of the given binary data string
-    def create_hex_string(data)
-      index = 0
-      str = ""
-      while index < data.length
-        # after 16 bytes insert a newline in the display
-        if index % 16 == 0
-          # don't insert a newline the first time
-          if index != 0
-            str << "\n"
-          end
-          str << "0x%08X: " % index
-        # every 4 bytes insert a space for readability
-        elsif index % 4 == 0
-          str << " "
-        end
-        str << "%02X" % data.getbyte(index)
-        index += 1
-      end
-      return str, index
+      result
     end
 
     # Set all the binary data in the table definition to the default values

data/lib/cosmos/tools/test_runner/test_runner.rb

@@ -1112,16 +1112,21 @@ module Cosmos
       @@test_suites = @@test_suites.select {|my_suite| my_suite.name == 'CustomTestSuite'}
       tests         = []
       ObjectSpace.each_object(Class) do |object|
-        next if object.name == 'CustomTestSuite'
-        if (object.ancestors.include?(TestSuite) &&
-            object != TestSuite &&
-            !ignored_test_suite_classes.include?(object))
-          @@test_suites << object.new
-        end
-        if (object.ancestors.include?(Test) &&
-            object != Test &&
-            !ignored_test_classes.include?(object))
-          tests << object
+        begin
+          next if object.name == 'CustomTestSuite'
+          if (object.ancestors.include?(TestSuite) &&
+              object != TestSuite &&
+              !ignored_test_suite_classes.include?(object))
+            @@test_suites << object.new
+          end
+          if (object.ancestors.include?(Test) &&
+              object != Test &&
+              !ignored_test_classes.include?(object))
+            tests << object
+          end
+        rescue
+          # Ignore Classes where name, etc may raise exception
+          # Bundler::Molinillo::DependencyGraph::Action is one example
         end
       end
       # Raise error if no test suites or tests

data/lib/cosmos/tools/tlm_viewer/widgets/checkbutton_widget.rb

@@ -16,16 +16,23 @@ module Cosmos
   class CheckbuttonWidget < Qt::CheckBox
     include Widget
 
-    def initialize(parent_layout, checkbutton_text)
+    def initialize(parent_layout, checkbutton_text, checked = 'UNCHECKED')
       super()
       setText(checkbutton_text.to_s)
+      case checked.to_s
+      when 'CHECKED'
+        setChecked(true)
+      when 'UNCHECKED'
+        setChecked(false)
+      else
+        raise "Unknown option '#{checked}' given to #{self.class}"
+      end
       parent_layout.addWidget(self) if parent_layout
     end
 
     def checked?
       self.isChecked()
     end
-
   end
 
 end # module Cosmos

data/lib/cosmos/tools/tlm_viewer/widgets/combobox_widget.rb

@@ -15,7 +15,7 @@ module Cosmos
   class ComboboxWidget < Qt::ComboBox
     include Widget
 
-    def initialize (parent_layout, *combobox_items)
+    def initialize(parent_layout, *combobox_items)
       super()
       addItems(combobox_items)
       self.maxVisibleItems = combobox_items.length > 6 ? 6 : combobox_items.length

data/lib/cosmos/tools/tlm_viewer/widgets/radiobutton_widget.rb

@@ -16,9 +16,17 @@ module Cosmos
   class RadiobuttonWidget < Qt::RadioButton
     include Widget
 
-    def initialize (parent_layout, radiobutton_text)
+    def initialize(parent_layout, radiobutton_text, checked = 'UNCHECKED')
       super()
       setText(radiobutton_text.to_s)
+      case checked.to_s
+      when 'CHECKED'
+        setChecked(true)
+      when 'UNCHECKED'
+        setChecked(false)
+      else
+        raise "Unknown option '#{checked}' given to #{self.class}"
+      end
       parent_layout.addWidget(self) if parent_layout
     end
 

data/lib/cosmos/top_level.rb

@@ -457,11 +457,11 @@ module Cosmos
         file.puts "Cosmos::USERPATH: #{Cosmos::USERPATH}"
         file.puts ""
         file.puts "Environment:"
-        file.puts "RUBYOPT: #{ENV['GEM_HOME']}"
-        file.puts "RUBYLIB: #{ENV['GEM_HOME']}"
-        file.puts "GEM_PATH: #{ENV['GEM_HOME']}"
-        file.puts "GEMRC: #{ENV['GEM_HOME']}"
-        file.puts "RI_DEVKIT: #{ENV['GEM_HOME']}"
+        file.puts "RUBYOPT: #{ENV['RUBYOPT']}"
+        file.puts "RUBYLIB: #{ENV['RUBYLIB']}"
+        file.puts "GEM_PATH: #{ENV['GEM_PATH']}"
+        file.puts "GEMRC: #{ENV['GEMRC']}"
+        file.puts "RI_DEVKIT: #{ENV['RI_DEVKIT']}"
         file.puts "GEM_HOME: #{ENV['GEM_HOME']}"
         file.puts "PATH: #{ENV['PATH']}"
         file.puts ""

data/lib/cosmos/version.rb

@@ -1,12 +1,12 @@
 # encoding: ascii-8bit
 
-COSMOS_VERSION = '3.8.2'
+COSMOS_VERSION = '3.8.3'
 module Cosmos
   module Version
     MAJOR = '3'
     MINOR = '8'
-    PATCH = '2'
-    BUILD = '8283169565fc37b09011e37193d511ff15a7d42c'
+    PATCH = '3'
+    BUILD = 'e6be858ed961d6fe872435be2b74c3499167a62a'
   end
-  VERSION = '3.8.2'
+  VERSION = '3.8.3'
 end

data/spec/config/config_parser_spec.rb

@@ -55,7 +55,45 @@ module Cosmos
         tf.unlink
       end
 
-      it "optionallies not remove quotes" do
+      it "supports ERB syntax" do
+        tf = Tempfile.new('unittest')
+        tf.puts "KEYWORD <%= 5 * 2 %>"
+        tf.close
+
+        @cp.parse_file(tf.path) do |keyword, params|
+          expect(keyword).to eql "KEYWORD"
+          expect(params[0]).to eql "10"
+        end
+        tf.unlink
+      end
+
+      it "supports ERB partials via render" do
+        tf2 = Tempfile.new('partial.txt')
+        tf2.puts '<% if output %>'
+        tf2.puts 'KEYWORD <%= id %> <%= desc %>'
+        tf2.puts '<% end %>'
+        tf2.close
+
+        # Run the test twice to verify the KEYWORD gets rendered and then doesn't
+        [true, false].each do |output|
+          tf = Tempfile.new('unittest')
+          tf.puts "<%= render '#{File.basename(tf2.path)}', locals: {id: 1, desc: 'Description', output: #{output}} %>"
+          tf.close
+
+          yielded = false
+          @cp.parse_file(tf.path) do |keyword, params|
+            yielded = true
+            expect(keyword).to eql "KEYWORD"
+            expect(params[0]).to eql "1"
+            expect(params[1]).to eql "Description"
+          end
+          expect(yielded).to eql output
+          tf.unlink
+        end
+        tf2.unlink
+      end
+
+      it "optionally does not remove quotes" do
         tf = Tempfile.new('unittest')
         line = "KEYWORD PARAM1 PARAM2 'PARAM 3'"
         tf.puts line
@@ -106,7 +144,7 @@ module Cosmos
         tf.unlink
       end
 
-      it "optionallies yield comment lines" do
+      it "optionally yields comment lines" do
         tf = Tempfile.new('unittest')
         tf.puts "KEYWORD1 PARAM1"
         tf.puts "# This is a comment"

data/spec/packet_logs/packet_log_reader_spec.rb

@@ -39,8 +39,8 @@ module Cosmos
       plw.write(pkt)
       @cmd_packets << pkt
       plw.stop
-      plw = PacketLogWriter.new(:TLM,nil,true,nil,10000000,nil,false)
 
+      plw = PacketLogWriter.new(:TLM,nil,true,nil,10000000,nil,false)
       @tlm_packets = []
       pkt = System.telemetry.packet("COSMOS","VERSION").clone
       pkt.received_time = Time.new(2020,2,1,12,30,15)
@@ -259,7 +259,7 @@ module Cosmos
         end
       end
 
-      it "optionallies not identify and define packets" do
+      it "optionally does not identify and define packets" do
         index = 0
         @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], false) do |packet|
           expect(packet.target_name).to eql @cmd_packets[index].target_name
@@ -278,6 +278,70 @@ module Cosmos
         end
       end
 
+      it "increments the command received count" do
+        plw = PacketLogWriter.new(:CMD,'cnt',true,nil,10000000,nil,false)
+        plw.write(System.commands.packet("INST","COLLECT").clone)
+        plw.write(System.commands.packet("INST","ABORT").clone)
+        plw.write(System.commands.packet("INST","ABORT").clone)
+        plw.write(System.commands.packet("INST","COLLECT").clone)
+        plw.write(System.commands.packet("COSMOS","STOPLOGGING").clone)
+        plw.write(System.commands.packet("INST","ABORT").clone)
+        plw.stop
+
+        cnt = {}
+        @plr.each(Dir[File.join(@log_path,"*cntcmd.bin")][0]) do |packet|
+          cnt["#{packet.target_name}_#{packet.packet_name}"] ||= 0
+          cnt["#{packet.target_name}_#{packet.packet_name}"] += 1
+          expect(packet.received_count).to eql cnt["#{packet.target_name}_#{packet.packet_name}"]
+        end
+
+        # Resetting a packet should reset only that packet's received_count
+        collect = System.commands.packet("INST","COLLECT")
+        collect.reset
+        cnt["INST_COLLECT"] = 0
+        expect(collect.received_count).to eql 0
+
+        @plr.each(Dir[File.join(@log_path,"*cntcmd.bin")][0]) do |packet|
+          cnt["#{packet.target_name}_#{packet.packet_name}"] ||= 0
+          cnt["#{packet.target_name}_#{packet.packet_name}"] += 1
+          expect(packet.received_count).to eql cnt["#{packet.target_name}_#{packet.packet_name}"]
+        end
+
+        Dir[File.join(@log_path,"*cntcmd.bin")].each {|file| FileUtils.rm file }
+      end
+
+      it "increments the telemetry received count" do
+        plw = PacketLogWriter.new(:TLM,'cnt',true,nil,10000000,nil,false)
+        plw.write(System.telemetry.packet("INST","HEALTH_STATUS").clone)
+        plw.write(System.telemetry.packet("INST","ADCS").clone)
+        plw.write(System.telemetry.packet("INST","ADCS").clone)
+        plw.write(System.telemetry.packet("INST","HEALTH_STATUS").clone)
+        plw.write(System.telemetry.packet("COSMOS","LIMITS_CHANGE").clone)
+        plw.write(System.telemetry.packet("INST","ADCS").clone)
+        plw.stop
+
+        cnt = {}
+        @plr.each(Dir[File.join(@log_path,"*cnttlm.bin")][0]) do |packet|
+          cnt["#{packet.target_name}_#{packet.packet_name}"] ||= 0
+          cnt["#{packet.target_name}_#{packet.packet_name}"] += 1
+          expect(packet.received_count).to eql cnt["#{packet.target_name}_#{packet.packet_name}"]
+        end
+
+        # Resetting a packet should reset only that packet's received_count
+        status = System.telemetry.packet("INST","HEALTH_STATUS")
+        status.reset
+        cnt["INST_HEALTH_STATUS"] = 0
+        expect(status.received_count).to eql 0
+
+        @plr.each(Dir[File.join(@log_path,"*cnttlm.bin")][0]) do |packet|
+          cnt["#{packet.target_name}_#{packet.packet_name}"] ||= 0
+          cnt["#{packet.target_name}_#{packet.packet_name}"] += 1
+          expect(packet.received_count).to eql cnt["#{packet.target_name}_#{packet.packet_name}"]
+        end
+
+        Dir[File.join(@log_path,"*cnttlm.bin")].each {|file| FileUtils.rm file }
+      end
+
       it "returns all packets if the start time is before all" do
         time = Time.new(2000,1,31,12,30,16)
         index = 0

data/spec/packets/packet_spec.rb

@@ -832,6 +832,33 @@ module Cosmos
         p.restore_defaults
         expect(p.buffer).to eql "\x03\x04\x01\x02\x04\x06\x08\x0A"
       end
+
+      it "writes all except skipped items back to their default values" do
+        p = Packet.new("tgt","pkt")
+        p.append_item("test1", 8, :UINT, 16)
+        i = p.get_item("TEST1")
+        i.default = [3,4]
+        p.write("test1", [1,2])
+        p.append_item("test2", 16, :UINT)
+        i = p.get_item("TEST2")
+        i.default = 0x0102
+        i.states = {"TRUE"=>0x0304}
+        p.write("test2", 0x0304)
+        p.append_item("test3", 32, :UINT)
+        i = p.get_item("TEST3")
+        i.default = 0x02030405
+        i.write_conversion = GenericConversion.new("value * 2")
+        p.write("test3", 0x01020304)
+        expect(p.buffer).to eql "\x01\x02\x03\x04\x02\x04\x06\x08"
+        p.restore_defaults(p.buffer(false), ["test1", "test2", "test3"])
+        expect(p.buffer).to eql "\x01\x02\x03\x04\x02\x04\x06\x08"
+        p.restore_defaults(p.buffer(false), ["test1", "test3"])
+        expect(p.buffer).to eql "\x01\x02\x01\x02\x02\x04\x06\x08"
+        p.restore_defaults(p.buffer(false), ["test3"])
+        expect(p.buffer).to eql "\x03\x04\x01\x02\x02\x04\x06\x08"
+        p.restore_defaults(p.buffer(false))
+        expect(p.buffer).to eql "\x03\x04\x01\x02\x04\x06\x08\x0A"
+      end
     end
 
     describe "enable_limits" do

data/spec/script/scripting_spec.rb

@@ -474,9 +474,14 @@ module Cosmos
         end
         allow(ScriptRunnerFrame).to receive_message_chain(:instance, :use_instrumentation)
         allow(ScriptRunnerFrame).to receive_message_chain(:instance, :use_instrumentation=)
-        load_utility("cosmos.rb")
+        script = File.join(Cosmos::USERPATH,'lib','example.rb')
+        File.open(script, 'w') { |file| file.puts "# Example script" }
+        not_cached = load_utility("example.rb")
+        expect(not_cached).to eq true
         # This one should use the cached version
-        load_utility("cosmos.rb")
+        not_cached = load_utility("example.rb")
+        expect(not_cached).to eq false
+        File.delete script
       end
     end