cosmos 4.3.0-java → 4.4.0-java

data/spec/interfaces/protocols/template_protocol_spec.rb

@@ -28,6 +28,7 @@ module Cosmos
     before(:each) do
       @interface = StreamInterface.new
       allow(@interface).to receive(:connected?) { true }
+      $write_buffer = ''
       $read_buffer = ''
       $read_cnt = 0
     end
@@ -173,12 +174,20 @@ module Cosmos
       end
 
       it "processes responses with no ID fields" do
-        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
-        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
-        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        tf = Tempfile.new('unittest')
+        tf.puts 'TELEMETRY TGT READ_VOLTAGE BIG_ENDIAN'
+        tf.puts '  APPEND_ITEM VOLTAGE 16 UINT'
+        tf.close
+        pc = PacketConfig.new
+        pc.process_file(tf.path, "SYSTEM")
+        telemetry = Telemetry.new(pc)
+        tf.unlink
+
+        allow(System).to receive_message_chain(:telemetry).and_return(telemetry)
         @interface.instance_variable_set(:@stream, TemplateStream.new)
         @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 nil 1 true 0 nil false nil nil), :READ_WRITE)
-        @interface.target_names = ['TGT']
+        # Add extra target names to the interface to ensure we grab the correct one
+        @interface.target_names = ['BLAH','TGT','OTHER']
         packet = Packet.new('TGT', 'CMD')
         packet.append_item("VOLTAGE", 16, :UINT)
         packet.get_item("VOLTAGE").default = 11
@@ -198,13 +207,21 @@ module Cosmos
         @interface.write(packet)
         sleep 0.55
         expect($write_buffer).to eql("SOUR:VOLT 11, (@1)\xAB\xCD")
+        expect(read_result.read("VOLTAGE")).to eql(10)
       end
 
       it "sets the response ID to the defined ID value" do
-        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
-        rsp_pkt.append_item("PKT_ID", 16, :UINT, nil, :BIG_ENDIAN, :ERROR, nil, nil, nil, 1) # ID == 1
-        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
-        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        tf = Tempfile.new('unittest')
+        tf.puts 'TELEMETRY TGT READ_VOLTAGE BIG_ENDIAN'
+        tf.puts '  APPEND_ID_ITEM PKT_ID 16 UINT 1'
+        tf.puts '  APPEND_ITEM VOLTAGE 16 UINT'
+        tf.close
+        pc = PacketConfig.new
+        pc.process_file(tf.path, "SYSTEM")
+        telemetry = Telemetry.new(pc)
+        tf.unlink
+
+        allow(System).to receive_message_chain(:telemetry).and_return(telemetry)
         @interface.instance_variable_set(:@stream, TemplateStream.new)
         @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 nil 1 true 0 nil false nil nil), :READ_WRITE)
         @interface.target_names = ['TGT']
@@ -230,14 +247,22 @@ module Cosmos
         sleep 0.55
         expect($write_buffer).to eql("SOUR:VOLT 11, (@1)\xAB\xCD")
         expect(read_result.read("PKT_ID")).to eql(1) # Result ID set to the defined value
+        expect(read_result.read("VOLTAGE")).to eql(10)
       end
 
       it "handles multiple response IDs" do
-        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
-        rsp_pkt.append_item("APID", 16, :UINT, nil, :BIG_ENDIAN, :ERROR, nil, nil, nil, 10) # ID == 10
-        rsp_pkt.append_item("PKTID", 16, :UINT, nil, :BIG_ENDIAN, :ERROR, nil, nil, nil, 20) # ID == 20
-        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
-        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        tf = Tempfile.new('unittest')
+        tf.puts 'TELEMETRY TGT READ_VOLTAGE BIG_ENDIAN'
+        tf.puts '  APPEND_ID_ITEM APID 16 UINT 10'
+        tf.puts '  APPEND_ID_ITEM PKTID 16 UINT 20'
+        tf.puts '  APPEND_ITEM VOLTAGE 16 UINT'
+        tf.close
+        pc = PacketConfig.new
+        pc.process_file(tf.path, "SYSTEM")
+        telemetry = Telemetry.new(pc)
+        tf.unlink
+
+        allow(System).to receive_message_chain(:telemetry).and_return(telemetry)
         @interface.instance_variable_set(:@stream, TemplateStream.new)
         @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 nil 1 true 0 nil false nil nil), :READ_WRITE)
         @interface.target_names = ['TGT']
@@ -272,9 +297,16 @@ module Cosmos
       end
 
       it "handles templates with more values than the response" do
-        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
-        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
-        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        tf = Tempfile.new('unittest')
+        tf.puts 'TELEMETRY TGT READ_VOLTAGE BIG_ENDIAN'
+        tf.puts '  APPEND_ITEM VOLTAGE 16 UINT'
+        tf.close
+        pc = PacketConfig.new
+        pc.process_file(tf.path, "SYSTEM")
+        telemetry = Telemetry.new(pc)
+        tf.unlink
+
+        allow(System).to receive_message_chain(:telemetry).and_return(telemetry)
         @interface.instance_variable_set(:@stream, TemplateStream.new)
         @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 nil 1 true 0 nil false nil), :READ_WRITE)
         @interface.target_names = ['TGT']
@@ -304,9 +336,16 @@ module Cosmos
       end
 
       it "handles responses with more values than the template" do
-        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
-        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
-        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        tf = Tempfile.new('unittest')
+        tf.puts 'TELEMETRY TGT READ_VOLTAGE BIG_ENDIAN'
+        tf.puts '  APPEND_ITEM VOLTAGE 16 UINT'
+        tf.close
+        pc = PacketConfig.new
+        pc.process_file(tf.path, "SYSTEM")
+        telemetry = Telemetry.new(pc)
+        tf.unlink
+
+        allow(System).to receive_message_chain(:telemetry).and_return(telemetry)
         @interface.instance_variable_set(:@stream, TemplateStream.new)
         @interface.add_protocol(TemplateProtocol, %w(0xABCD 0xABCD 0 nil 1 true 0 nil false nil), :READ_WRITE)
         @interface.target_names = ['TGT']
@@ -336,9 +375,16 @@ module Cosmos
       end
 
       it "ignores response lines" do
-        rsp_pkt = Packet.new('TGT', 'READ_VOLTAGE')
-        rsp_pkt.append_item("VOLTAGE", 16, :UINT)
-        allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+        tf = Tempfile.new('unittest')
+        tf.puts 'TELEMETRY TGT READ_VOLTAGE BIG_ENDIAN'
+        tf.puts '  APPEND_ITEM VOLTAGE 16 UINT'
+        tf.close
+        pc = PacketConfig.new
+        pc.process_file(tf.path, "SYSTEM")
+        telemetry = Telemetry.new(pc)
+        tf.unlink
+
+        allow(System).to receive_message_chain(:telemetry).and_return(telemetry)
         @interface.instance_variable_set(:@stream, TemplateStream.new)
         @interface.add_protocol(TemplateProtocol, %w(0xAD 0xA 1), :READ_WRITE)
         @interface.target_names = ['TGT']
@@ -365,9 +411,16 @@ module Cosmos
     end
 
     it "allows multiple response lines" do
-      rsp_pkt = Packet.new('TGT', 'DATA')
-      rsp_pkt.append_item("STRING", 512, :STRING)
-      allow(System).to receive_message_chain(:telemetry, :packet).and_return(rsp_pkt)
+      tf = Tempfile.new('unittest')
+      tf.puts 'TELEMETRY TGT DATA BIG_ENDIAN'
+      tf.puts '  APPEND_ITEM STRING 512 STRINg'
+      tf.close
+      pc = PacketConfig.new
+      pc.process_file(tf.path, "SYSTEM")
+      telemetry = Telemetry.new(pc)
+      tf.unlink
+
+      allow(System).to receive_message_chain(:telemetry).and_return(telemetry)
       @interface.instance_variable_set(:@stream, TemplateStream.new)
       @interface.add_protocol(TemplateProtocol, %w(0xAD 0xA 0 nil 2), :READ_WRITE)
       @interface.target_names = ['TGT']

data/spec/packets/commands_spec.rb

@@ -140,6 +140,28 @@ module Cosmos
         expect(pkt.item4).to eql 4
       end
 
+      it "works in unique id mode or not" do
+        System.targets["TGT1"] = Target.new("TGT1")
+        target = System.targets["TGT1"]
+        target.cmd_unique_id_mode = false
+        buffer = "\x01\x02\x03\x04"
+        pkt = @cmd.identify(buffer,["TGT1"])
+        pkt.enable_method_missing
+        expect(pkt.item1).to eql 1
+        expect(pkt.item2).to eql 2
+        expect(pkt.item3).to eql 3
+        expect(pkt.item4).to eql 4
+        target.cmd_unique_id_mode = true
+        buffer = "\x01\x02\x01\x02"
+        pkt = @cmd.identify(buffer,["TGT1"])
+        pkt.enable_method_missing
+        expect(pkt.item1).to eql 1
+        expect(pkt.item2).to eql 2
+        expect(pkt.item3).to eql 1
+        expect(pkt.item4).to eql 2        
+        target.cmd_unique_id_mode = false
+      end
+
       it "returns nil with unknown targets given" do
         buffer = "\x01\x02\x03\x04"
         expect(@cmd.identify(buffer,["TGTX"])).to be_nil

data/spec/packets/packet_config_spec.rb

@@ -114,6 +114,30 @@ module Cosmos
             tf.unlink
           end
         end
+        
+        it "builds the id value hash" do
+          @tlm_keywords.each do |keyword|
+            next if %w(PROCESSOR META).include? keyword
+            tf = Tempfile.new('unittest')
+            tf.puts 'TELEMETRY tgt1 pkt1 BIG_ENDIAN "Packet"'
+            tf.puts 'ID_ITEM myitem 0 8 UINT 13 "Test Item id=1"'
+            tf.puts 'APPEND_ID_ITEM myitem 8 UINT 114 "Test Item id=1"'
+            tf.puts 'COMMAND tgt1 pkt1 BIG_ENDIAN "Packet"'
+            tf.puts 'ID_PARAMETER myitem 0 8 UINT 12 12 12 "Test Item id=1"'
+            tf.puts 'APPEND_ID_PARAMETER myitem 8 UINT 115 115 115 "Test Item id=1"'
+            tf.close
+            @pc.process_file(tf.path, "TGT1")
+            expected_tlm_hash = {}
+            expected_tlm_hash["TGT1"] = {}
+            expected_tlm_hash["TGT1"][[13, 114]] = @pc.telemetry["TGT1"]["PKT1"]
+            expected_cmd_hash = {}
+            expected_cmd_hash["TGT1"] = {}
+            expected_cmd_hash["TGT1"][[12, 115]] = @pc.commands["TGT1"]["PKT1"]            
+            expect(@pc.tlm_id_value_hash).to eql expected_tlm_hash
+            expect(@pc.cmd_id_value_hash).to eql expected_cmd_hash
+            tf.unlink
+          end          
+        end
 
         it "complains if there are too many parameters" do
           @top_keywords.each do |keyword|

data/spec/packets/packet_item_spec.rb

@@ -400,7 +400,7 @@ module Cosmos
         @pi.read_conversion = GenericConversion.new("value / 2")
         @pi.write_conversion = GenericConversion.new("value * 2")
         @pi.description = "description"
-        @pi.units_full = "Celcius"
+        @pi.units_full = "Celsius"
         @pi.units = "C"
         @pi.default = 0
         @pi.range = (0..100)
@@ -428,7 +428,7 @@ module Cosmos
         expect(hash["id_value"]).to eql 10
         expect(hash["states"]).to include("TRUE"=>1,"FALSE"=>0)
         expect(hash["description"]).to eql "description"
-        expect(hash["units_full"]).to eql "Celcius"
+        expect(hash["units_full"]).to eql "Celsius"
         expect(hash["units"]).to eql "C"
         expect(hash["default"]).to eql 0
         expect(hash["range"]).to eql (0..100)

data/spec/packets/packet_spec.rb

@@ -707,7 +707,7 @@ module Cosmos
     end
 
     describe "formatted" do
-      it "prints out all the items and CONVERTED values" do
+      it "prints out all the items" do
         p = Packet.new("tgt","pkt")
         p.append_item("test1", 8, :UINT, 16)
         p.write("test1", [1,2])
@@ -727,6 +727,25 @@ module Cosmos
         expect(p.formatted).to include("TEST2: TRUE")
         expect(p.formatted).to include("TEST3: #{0x02030405}")
         expect(p.formatted).to include("TEST4: Test")
+        # Test the data_type parameter
+        expect(p.formatted(:RAW)).to include("TEST1: [1, 2]")
+        expect(p.formatted(:RAW)).to include("TEST2: #{0x0304}")
+        expect(p.formatted(:RAW)).to include("TEST3: #{0x0406080A}")
+        expect(p.formatted(:RAW)).to include("00000000: 54 65 73 74") # Raw TEST4 block
+        # Test the indent parameter
+        expect(p.formatted(:CONVERTED, 4)).to include("    TEST1: [1, 2]")
+        # Test the buffer parameter
+        buffer = "\x02\x03\x04\x05\x00\x00\x00\x02\x44\x45\x41\x44"
+        expect(p.formatted(:CONVERTED, 0, buffer)).to include("TEST1: [2, 3]")
+        expect(p.formatted(:CONVERTED, 0, buffer)).to include("TEST2: #{0x0405}")
+        expect(p.formatted(:CONVERTED, 0, buffer)).to include("TEST3: 1")
+        expect(p.formatted(:CONVERTED, 0, buffer)).to include("TEST4: DEAD")
+        # Test the ignored parameter
+        string = p.formatted(:CONVERTED, 0, p.buffer, %w(TEST1 TEST4))
+        expect(string).not_to include("TEST1")
+        expect(string).to include("TEST2: TRUE")
+        expect(string).to include("TEST3: #{0x02030405}")
+        expect(string).not_to include("TEST4")
       end
     end
 
@@ -828,12 +847,26 @@ module Cosmos
       it "returns an array of the identifying items" do
         p = Packet.new("tgt","pkt")
         p.define_item("item1",0,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,nil)
-        p.define_item("item2",0,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,5)
-        p.define_item("item3",0,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,nil)
-        p.define_item("item4",0,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,6)
+        p.define_item("item2",64,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,5)
+        p.define_item("item3",96,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,nil)
+        p.define_item("item4",32,32,:FLOAT,nil,:BIG_ENDIAN,:ERROR,"%5.1f",nil,nil,6)        
         expect(p.id_items).to be_a Array
-        expect(p.id_items[0].name).to eq "ITEM2"
-        expect(p.id_items[1].name).to eq "ITEM4"
+        expect(p.id_items[0].name).to eq "ITEM4"
+        expect(p.id_items[1].name).to eq "ITEM2"
+      end
+    end
+
+    describe "read_id_values" do
+      it "to read the right values" do
+        buffer = "\x00\x00\x00\x04\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\x01"
+        p = Packet.new("tgt","pkt")
+        p.define_item("item1",0,32,:UINT,nil,:BIG_ENDIAN,:ERROR,nil,nil,nil,nil)
+        p.define_item("item2",64,32,:UINT,nil,:BIG_ENDIAN,:ERROR,nil,nil,nil,5)
+        p.define_item("item3",96,32,:UINT,nil,:BIG_ENDIAN,:ERROR,nil,nil,nil,nil)
+        p.define_item("item4",32,32,:UINT,nil,:BIG_ENDIAN,:ERROR,nil,nil,nil,6)
+        values = p.read_id_values(buffer)
+        expect(values[0]).to eq 3
+        expect(values[1]).to eq 2
       end
     end
 

data/spec/packets/parsers/state_parser_spec.rb

@@ -54,17 +54,6 @@ module Cosmos
         tf.unlink
       end
 
-      it "complains if FORMAT_STRING defined" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
-        tf.puts '  ITEM myitem 0 8 UINT "Test Item"'
-        tf.puts '    FORMAT_STRING "0x%x"'
-        tf.puts '    STATE ONE 1'
-        tf.close
-        expect { @pc.process_file(tf.path, "TGT1") }.to raise_error(ConfigParser::Error, /Items with FORMAT_STRING can't define STATE/)
-        tf.unlink
-      end
-
       it "complains if UNITS defined" do
         tf = Tempfile.new('unittest')
         tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
@@ -135,6 +124,39 @@ module Cosmos
           tf.unlink
         end
 
+        it "uses state or FORMAT_STRING if no state" do
+          tf = Tempfile.new('unittest')
+          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
+          tf.puts '  APPEND_ITEM item1 8 UINT "Test Item"'
+          tf.puts '    FORMAT_STRING "0x%x"'
+          tf.puts '    STATE ONE 1'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          tlm = Telemetry.new(@pc)
+          pkt = tlm.packet("TGT1", "PKT1")
+          pkt.write("ITEM1", 1)
+          expect(pkt.read("ITEM1", :FORMATTED)).to eql "ONE"
+          pkt.write("ITEM1", 2)
+          expect(pkt.read("ITEM1", :FORMATTED)).to eql "0x2"
+          tf.unlink
+
+          # Ensure the order of STATE vs FORMAT_STRING doesn't matter
+          tf = Tempfile.new('unittest')
+          tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Packet"'
+          tf.puts '  APPEND_ITEM item1 8 UINT "Test Item"'
+          tf.puts '    STATE ONE 1'
+          tf.puts '    FORMAT_STRING "0x%x"'
+          tf.close
+          @pc.process_file(tf.path, "TGT1")
+          tlm = Telemetry.new(@pc)
+          pkt = tlm.packet("TGT1", "PKT1")
+          pkt.write("ITEM1", 1)
+          expect(pkt.read("ITEM1", :FORMATTED)).to eql "ONE"
+          pkt.write("ITEM1", 2)
+          expect(pkt.read("ITEM1", :FORMATTED)).to eql "0x2"
+          tf.unlink
+        end
+
         it "allows an 'ANY' state" do
           tf = Tempfile.new('unittest')
           tf.puts 'TELEMETRY tgt1 pkt1 LITTLE_ENDIAN "Description"'

data/spec/packets/structure_spec.rb

@@ -348,6 +348,20 @@ module Cosmos
         expect(s.read("test1", :RAW, buffer)).to eql 1
       end
 
+      it "reads until null byte for STRING items" do
+        s = Structure.new
+        s.define_item("test1", 0, 80, :STRING)
+        buffer = "\x4E\x4F\x4F\x50\x00\x4E\x4F\x4F\x50\x0A" # NOOP<NULL>NOOP\n
+        expect(s.read("test1", :CONVERTED, buffer)).to eql "NOOP"
+      end
+
+      it "reads the entire buffer for BLOCK items" do
+        s = Structure.new
+        s.define_item("test1", 0, 80, :BLOCK)
+        buffer = "\x4E\x4F\x4F\x50\x00\x4E\x4F\x4F\x50\x0A" # NOOP<NULL>NOOP\n
+        expect(s.read("test1", :CONVERTED, buffer)).to eql "NOOP\x00NOOP\n"
+      end
+
       it "reads array data from the buffer" do
         s = Structure.new
         s.define_item("test1", 0, 8, :UINT, 16)
@@ -442,6 +456,33 @@ module Cosmos
         expect(s.formatted(:CONVERTED, 4)).to include("    TEST3")
         expect(s.formatted(:CONVERTED, 4)).to include("    00000000: 07 08 09 0A")
       end
+
+      it "processes uses a different buffer" do
+        s = Structure.new(:BIG_ENDIAN)
+        s.append_item("test1", 8, :UINT, 16)
+        s.write("test1", [1,2])
+        s.append_item("test2", 16, :UINT)
+        s.write("test2", 3456)
+        s.append_item("test3", 32, :BLOCK)
+        s.write("test3", "\x07\x08\x09\x0A")
+        buffer = "\x0A\x0B\x0C\x0D\xDE\xAD\xBE\xEF"
+        expect(s.formatted(:CONVERTED, 0, buffer)).to include("TEST1: [10, 11]")
+        expect(s.formatted(:CONVERTED, 0, buffer)).to include("TEST2: #{0x0C0D}")
+        expect(s.formatted(:CONVERTED, 0, buffer)).to include("TEST3")
+        expect(s.formatted(:CONVERTED, 0, buffer)).to include("00000000: DE AD BE EF")
+      end
+
+      it "ignores items" do
+        s = Structure.new(:BIG_ENDIAN)
+        s.append_item("test1", 8, :UINT, 16)
+        s.write("test1", [1,2])
+        s.append_item("test2", 16, :UINT)
+        s.write("test2", 3456)
+        s.append_item("test3", 32, :BLOCK)
+        s.write("test3", "\x07\x08\x09\x0A")
+        expect(s.formatted(:CONVERTED, 0, s.buffer, %w(TEST1 TEST3))).to eq("TEST2: 3456\n")
+        expect(s.formatted(:CONVERTED, 0, s.buffer, %w(TEST1 TEST2 TEST3))).to eq("")
+      end
     end
 
     describe "buffer" do

data/spec/packets/telemetry_spec.rb

@@ -257,6 +257,29 @@ module Cosmos
         expect(pkt.item3).to eql 6.0
         expect(pkt.item4).to eql 8.0
       end
+      
+      it "works in unique id mode and not" do
+        System.targets["TGT1"] = Target.new("TGT1")
+        target = System.targets["TGT1"]
+        buffer = "\x01\x02\x03\x04"
+        target.tlm_unique_id_mode = false
+        pkt = @tlm.identify!(buffer,["TGT1"])
+        pkt.enable_method_missing
+        expect(pkt.item1).to eql 1
+        expect(pkt.item2).to eql 2
+        expect(pkt.item3).to eql 6.0
+        expect(pkt.item4).to eql 8.0
+        buffer = "\x01\x02\x01\x02"
+        target.tlm_unique_id_mode = true
+        @tlm.identify!(buffer,["TGT1"])
+        pkt = @tlm.packet("TGT1","PKT1")
+        pkt.enable_method_missing
+        expect(pkt.item1).to eql 1
+        expect(pkt.item2).to eql 2
+        expect(pkt.item3).to eql 2.0
+        expect(pkt.item4).to eql 4.0        
+        target.tlm_unique_id_mode = false
+      end      
 
       it "returns nil with unknown targets given" do
         buffer = "\x01\x02\x03\x04"