stupidedi 1.1.0 → 1.2.1

data/spec/examples/integration/navigating.example

@@ -18,7 +18,7 @@ describe "Navigating" do
   context "parent segments" do
     specify "the first ISA is a root" do
       # ISA has no parent segment
-      payment.flatmap(&:parent).should_not be_defined
+      expect(payment.flatmap(&:parent)).not_to be_defined
     end
 
     specify "the second ISA's parent is the first ISA" do
@@ -34,7 +34,7 @@ describe "Navigating" do
                 "", "00501", 123456789, "1", "T", "")
 
           # The ISA segment we just added has the first ISA for a dad
-          b.machine.should have_parent(isa)
+          expect(b.machine).to have_parent(isa)
         end
       end
     end
@@ -42,29 +42,29 @@ describe "Navigating" do
 
   context "segments" do
     specify do
-      payment.flatmap(&:segment).tap do |isa|
-        isa.node.should be_segment
-        isa.node.id.should == :ISA
-      end.should be_defined
+      expect(payment.flatmap(&:segment).tap do |isa|
+        expect(isa.node).to be_segment
+        expect(isa.node.id).to eq(:ISA)
+      end).to be_defined
     end
   end
 
   describe "error handling" do
     context "accessing an undefined element" do
       it "raises an exception" do
-        lambda { payment.tap{|isa| isa.element(40) }}.should \
+        expect(lambda { payment.tap{|isa| isa.element(40) }}).to \
           raise_error("ISA segment has only 16 elements")
       end
 
       it "raises an exception" do
-        lambda { payment.tap{|isa| isa.element(0) }}.should \
+        expect(lambda { payment.tap{|isa| isa.element(0) }}).to \
           raise_error("argument must be positive")
       end
     end
 
     context "accessing an element of an invalid segment" do
       it "returns a failure" do
-        payment.flatmap(&:last).tap do |iea|
+        expect(payment.flatmap(&:last).tap do |iea|
           # non-strict builder used to append a bad segment (ISA version)
           b = Stupidedi::Builder::BuilderDsl.new(iea, false)
           b.ISA("00", "",
@@ -75,22 +75,22 @@ describe "Navigating" do
                 Time.now.utc,
                 "", "BAD-VERSION", 123456789, "1", "T", "")
 
-          b.machine.element(1).should_not be_defined
-          b.machine.element(1).reason.should == "invalid segment"
-        end.should be_defined
+          expect(b.machine.element(1)).not_to be_defined
+          expect(b.machine.element(1).reason).to eq("invalid segment")
+        end).to be_defined
       end
     end
 
     context "accessing a simple element as if it were a composite" do
       it "raises an exception" do
-        lambda { payment.flatmap{|isa| isa.element(1, 1) }}.should \
+        expect(lambda { payment.flatmap{|isa| isa.element(1, 1) }}).to \
           raise_error("ISA01 is a simple element")
       end
     end
 
     context "accessing a simple element as if it were a repeated composite" do
       it "raises an exception" do
-        lambda { payment.flatmap{|isa| isa.element(1, 1, 1) }}.should \
+        expect(lambda { payment.flatmap{|isa| isa.element(1, 1, 1) }}).to \
           raise_error("ISA01 is a simple element")
       end
     end
@@ -100,98 +100,98 @@ describe "Navigating" do
     context "using the segment zipper" do
 
       specify "StateMachine#zipper returns a zipper pointing at SegmentVal" do
-        payment.flatmap{|m| m.zipper.select{|z| z.node.segment? }}.should \
+        expect(payment.flatmap{|m| m.zipper.select{|z| z.node.segment? }}).to \
           be_defined
       end
 
       specify do
         payment.flatmap(&:zipper).tap do |z|
           # z is a zipper pointing to SegmentVal[ISA]
-          z.node.id.should == :ISA
+          expect(z.node.id).to eq(:ISA)
         end
       end
 
       it "is equivalent to using the state machine" do
-        claim.flatmap do |m|
+        expect(claim.flatmap do |m|
           m.segment.tap do |z|
             # z is a zipper pointing to SegmentVal[ISA]
             # m is a StateMachine pointing at that zipper
-            m.element( 1).tap{|e| e.node.should be_eql(z.node.element( 1)) }
-            m.element( 2).tap{|e| e.node.should be_eql(z.node.element( 2)) }
-            m.element( 3).tap{|e| e.node.should be_eql(z.node.element( 3)) }
-            m.element( 4).tap{|e| e.node.should be_eql(z.node.element( 4)) }
-            m.element( 5).tap{|e| e.node.should be_eql(z.node.element( 5)) }
-            m.element( 6).tap{|e| e.node.should be_eql(z.node.element( 6)) }
-            m.element( 7).tap{|e| e.node.should be_eql(z.node.element( 7)) }
-            m.element( 8).tap{|e| e.node.should be_eql(z.node.element( 8)) }
-            m.element( 9).tap{|e| e.node.should be_eql(z.node.element( 9)) }
-            m.element(10).tap{|e| e.node.should be_eql(z.node.element(10)) }
-            m.element(11).tap{|e| e.node.should be_eql(z.node.element(11)) }
-            m.element(12).tap{|e| e.node.should be_eql(z.node.element(12)) }
-            m.element(13).tap{|e| e.node.should be_eql(z.node.element(13)) }
-            m.element(14).tap{|e| e.node.should be_eql(z.node.element(14)) }
-            m.element(15).tap{|e| e.node.should be_eql(z.node.element(15)) }
-            m.element(16).tap{|e| e.node.should be_eql(z.node.element(16)) }
+            m.element( 1).tap{|e| expect(e.node).to be_eql(z.node.element( 1)) }
+            m.element( 2).tap{|e| expect(e.node).to be_eql(z.node.element( 2)) }
+            m.element( 3).tap{|e| expect(e.node).to be_eql(z.node.element( 3)) }
+            m.element( 4).tap{|e| expect(e.node).to be_eql(z.node.element( 4)) }
+            m.element( 5).tap{|e| expect(e.node).to be_eql(z.node.element( 5)) }
+            m.element( 6).tap{|e| expect(e.node).to be_eql(z.node.element( 6)) }
+            m.element( 7).tap{|e| expect(e.node).to be_eql(z.node.element( 7)) }
+            m.element( 8).tap{|e| expect(e.node).to be_eql(z.node.element( 8)) }
+            m.element( 9).tap{|e| expect(e.node).to be_eql(z.node.element( 9)) }
+            m.element(10).tap{|e| expect(e.node).to be_eql(z.node.element(10)) }
+            m.element(11).tap{|e| expect(e.node).to be_eql(z.node.element(11)) }
+            m.element(12).tap{|e| expect(e.node).to be_eql(z.node.element(12)) }
+            m.element(13).tap{|e| expect(e.node).to be_eql(z.node.element(13)) }
+            m.element(14).tap{|e| expect(e.node).to be_eql(z.node.element(14)) }
+            m.element(15).tap{|e| expect(e.node).to be_eql(z.node.element(15)) }
+            m.element(16).tap{|e| expect(e.node).to be_eql(z.node.element(16)) }
           end
-        end.should be_defined
+        end).to be_defined
 
-        claim.flatmap(&:next).flatmap do |m|
+        expect(claim.flatmap(&:next).flatmap do |m|
           m.segment.tap do |z|
             # z is a zipper pointing to SegmentVal[GS]
             # m is a StateMachine pointing at that zipper
-            m.element(1).tap{|e| e.node.should be_eql(z.node.element(1)) }
-            m.element(2).tap{|e| e.node.should be_eql(z.node.element(2)) }
-            m.element(3).tap{|e| e.node.should be_eql(z.node.element(3)) }
-            m.element(4).tap{|e| e.node.should be_eql(z.node.element(4)) }
-            m.element(5).tap{|e| e.node.should be_eql(z.node.element(5)) }
+            m.element(1).tap{|e| expect(e.node).to be_eql(z.node.element(1)) }
+            m.element(2).tap{|e| expect(e.node).to be_eql(z.node.element(2)) }
+            m.element(3).tap{|e| expect(e.node).to be_eql(z.node.element(3)) }
+            m.element(4).tap{|e| expect(e.node).to be_eql(z.node.element(4)) }
+            m.element(5).tap{|e| expect(e.node).to be_eql(z.node.element(5)) }
           end
-        end.should be_defined
+        end).to be_defined
       end
     end
 
     context "time elements" do
       specify "using the state machine" do
-        payment.flatmap{|isa| isa.element(10) }.tap do |tm|
-          tm.node.should be_time
-          tm.node.hour.should == 12
-          tm.node.minute.should == 53
-          tm.node.second.should be_nil
-        end.should be_defined
+        expect(payment.flatmap{|isa| isa.element(10) }.tap do |tm|
+          expect(tm.node).to be_time
+          expect(tm.node.hour).to eq(12)
+          expect(tm.node.minute).to eq(53)
+          expect(tm.node.second).to be_nil
+        end).to be_defined
       end
 
       specify "using the state machine" do
-        payment.flatmap(&:next).flatmap{|gs| gs.element(5) }.tap do |tm|
-          tm.node.should be_time
-          tm.node.hour.should == 8
-          tm.node.minute.should == 2
-          tm.node.second.should be_nil
-        end.should be_defined
+        expect(payment.flatmap(&:next).flatmap{|gs| gs.element(5) }.tap do |tm|
+          expect(tm.node).to be_time
+          expect(tm.node.hour).to eq(8)
+          expect(tm.node.minute).to eq(2)
+          expect(tm.node.second).to be_nil
+        end).to be_defined
       end
     end
 
     context "date elements" do
       specify do
         # This is the one "improper" date with 2-digit year
-        payment.flatmap{|isa| isa.element(9) }.tap do |dt|
-          dt.node.should be_date
-          dt.node.year.should  == 3
-          dt.node.month.should == 1
-          dt.node.day.should   == 1
-          dt.node.future.year.should == 2103
-          dt.node.past.year.should   == 2003
-        end.should be_defined
+        expect(payment.flatmap{|isa| isa.element(9) }.tap do |dt|
+          expect(dt.node).to be_date
+          expect(dt.node.year).to  eq(3)
+          expect(dt.node.month).to eq(1)
+          expect(dt.node.day).to  eq(1)
+          expect(dt.node.future.year).to eq(2103)
+          expect(dt.node.past.year).to eq(2003)
+        end).to be_defined
       end
 
       specify do
         # This is a typical "proper" date with 4-digit year
-        payment.flatmap(&:next).flatmap{|gs| gs.element(4) }.tap do |dt|
-          dt.node.should be_date
-          dt.node.year.should  == 1999
-          dt.node.month.should == 12
-          dt.node.day.should   == 31
-          dt.node.future.year.should == 1999
-          dt.node.past.year.should   == 1999
-        end.should be_defined
+        expect(payment.flatmap(&:next).flatmap{|gs| gs.element(4) }.tap do |dt|
+          expect(dt.node).to be_date
+          expect(dt.node.year).to eq(1999)
+          expect(dt.node.month).to eq(12)
+          expect(dt.node.day).to eq(31)
+          expect(dt.node.future.year).to eq(1999)
+          expect(dt.node.past.year).to eq(1999)
+        end).to be_defined
       end
     end
 

data/spec/examples/integration/parsing.example

@@ -7,24 +7,24 @@ describe "Parsing" do
     let(:parser) { Fixtures.file("X222-HC837/1-good.txt") }
 
     it "parses 1-good.txt" do
-      parser.should be_deterministic
-      parser.should be_last
+      expect(parser).to be_deterministic
+      expect(parser).to be_last
 
       parser.segment.tap do |iea|
-        iea.node.position.line.should   == 53
-        iea.node.position.column.should == 1
+        expect(iea.node.position.line).to eq(53)
+        expect(iea.node.position.column).to eq(1)
       end
 
-      parser.should have_sequence(%w(ISA GS ST BHT NM1 PER NM1 HL PRV NM1 N3 N4
+      expect(parser).to have_sequence(%w(ISA GS ST BHT NM1 PER NM1 HL PRV NM1 N3 N4
         REF NM1 N3 N4 HL SBR NM1 N3 N4 DMG NM1 N4 REF HL PAT NM1 N3 N4 DMG CLM
         REF HI LX SV1 DTP LX SV1 DTP LX SV1 DTP LX SV1 DTP SE GE IEA))
 
-      parser.should have_separators(:element => "*", :component => ":",
+      expect(parser).to have_separators(:element => "*", :component => ":",
                                     :repetition => "^", :segment => "~")
 
       parser.parent.tap do |isa|
         # Should have 49 total segments in the parse tree
-        isa.should have_distance(48).to(parser)
+        expect(isa).to have_distance(48).to(parser)
 
         # See matchers/navigation_matchers.rb
         #
@@ -35,7 +35,7 @@ describe "Parsing" do
         #  R: the segment might be reachable, but didn't occur
         #  X: the segment would never be reachable
         #
-        isa.should have_structure(
+        expect(isa).to have_structure(
           Ss(X(:ST),
              R(:ISA), # No more ISAs
              S(:GS, "HC", nil, nil, nil, nil, 1) =>
@@ -245,23 +245,23 @@ describe "Parsing" do
 
     it "parses 1-good.txt" do
       parser = Fixtures.file("X221-HP835/1-good.txt")
-      parser.should be_deterministic
-      parser.should be_last
+      expect(parser).to be_deterministic
+      expect(parser).to be_last
 
       parser.segment.tap do |iea|
-        iea.node.position.line.should   == 40
-        iea.node.position.column.should == 1
+        expect(iea.node.position.line).to eq(40)
+        expect(iea.node.position.column).to eq(1)
       end
 
-      parser.should have_sequence(%w(ISA GS ST BPR TRN DTM N1 N3 N4 REF REF
+      expect(parser).to have_sequence(%w(ISA GS ST BPR TRN DTM N1 N3 N4 REF REF
         N1 REF LX TS3 TS2 CLP CAS NM1 MIA DTM DTM AMT QTY LX TS3 CLP CAS
         NM1 MOA DTM AMT PLB SE GE IEA))
 
-      parser.should have_separators(:element => "+", :component => ">",
+      expect(parser).to have_separators(:element => "+", :component => ">",
                                     :repetition => "~", :segment => "\r")
 
       parser.parent.tap do |isa|
-        isa.should have_distance(35).to(parser)
+        expect(isa).to have_distance(35).to(parser)
 
         # See matchers/navigation_matchers.rb
         #
@@ -272,7 +272,7 @@ describe "Parsing" do
         #  R: the segment might be reachable, but didn't occur
         #  X: the segment would never be reachable
         #
-        isa.should have_structure(
+        expect(isa).to have_structure(
           Ss(X(:ST),
              R(:ISA), # No more ISAs
              S(:GS, "HP", nil, nil, "19991231", nil, 1) =>
@@ -359,10 +359,10 @@ describe "Parsing" do
     context "issues with Table 3 (Summary)" do
       it "handles missing PLB" do
         parser = Fixtures.file("X221-HP835/2-good.txt")
-        parser.should be_deterministic
+        expect(parser).to be_deterministic
 
         parser.parent.tap do |isa|
-          isa.should have_structure(
+          expect(isa).to have_structure(
             Ss(X(:SE),
                X(:PLB),
                S(:GS, "HP", nil, nil, "19991231", nil, 1) =>
@@ -381,10 +381,10 @@ describe "Parsing" do
 
       it "handles single PLB" do
         parser = Fixtures.file("X221-HP835/1-good.txt")
-        parser.should be_deterministic
+        expect(parser).to be_deterministic
 
         parser.parent.tap do |isa|
-          isa.should have_structure(
+          expect(isa).to have_structure(
             Ss(X(:SE),
                X(:PLB),
                S(:GS, "HP", nil, nil, "19991231", nil, 1) =>
@@ -405,10 +405,10 @@ describe "Parsing" do
 
       it "handles multiple PLBs" do
         parser = Fixtures.file("X221-HP835/3a-good.txt")
-        parser.should be_deterministic
+        expect(parser).to be_deterministic
 
         parser.parent.tap do |isa|
-          isa.should have_structure(
+          expect(isa).to have_structure(
             Ss(X(:SE),
                X(:PLB),
                S(:GS, "HP", nil, nil, "19991231", nil, 1) =>
@@ -440,6 +440,234 @@ describe "Parsing" do
       end
     end
 
+    context "table-level permutations" do
+      # 837
+      #   Table 2A
+      #     2000A HL*..*..*20
+      #   Table 2B
+      #     2000B HL*..*..*22
+      #   Table 2C
+      #     2000C HL*..*..*23
+      let(:dsl) do
+        c = Stupidedi::Config.hipaa
+        b = Stupidedi::Builder::BuilderDsl.build(c, false)
+        b.ISA("00", nil, "01", "SECRET", "ZZ", "SUBMITTER", "ZZ", "RECEIVER", Time.now.utc, Time.now.utc, nil, "00501", 123456789, "1", "T", nil)
+        b. GS("HP", "SENDER", "RECEIVER", Time.now.utc, Time.now.utc, 1, "X", "005010X222")
+        b. ST("837", "0001", b.default)
+          b.BHT("0019", "00", "46X2A6", Time.now.utc, Time.now.utc, "CH")
+          b.NM1("41", "2", "TERRIBLE BILLING", nil, nil, nil, nil, "46", "X82BJJ")
+            b.PER("IC", nil, "TE", "5551212")
+          b.NM1("40", "2", "TERRIBLE INSURAN", nil, nil, nil, nil, "46", "3057XK")
+
+        b # return BuilderDsl instance
+      end
+
+      specify "HL*..*..20, HL*..*..*22, HL*..*..*23" do
+        ss = [["1", nil, "20", "1"],
+              ["2", nil, "20", "1"],
+              ["3", "1", "22", "1"],
+              ["4", "2", "22", "1"],
+              ["5", "3", "23", "0"],
+              ["6", "4", "23", "0"]]
+
+        ss.permutation do |p|
+          b = dsl.dup
+          p.each{|es| b.send(:HL, *es) }
+
+          m = b.machine.first.flatmap{|x| x.sequence(:GS, :ST) }
+
+          expect(m.map{|x| x.count(:HL, nil, nil, "20") }).to be_success(2)
+          expect(m.map{|x| x.count(:HL, nil, nil, "22") }).to be_success(2)
+          expect(m.map{|x| x.count(:HL, nil, nil, "23") }).to be_success(2)
+
+          expect(m.map{|x| x.count(:HL) }).to be_success(6)
+
+          expect(m.flatmap{|x| x.sequence(:HL) }.
+            map{|x| x.count(:HL) }).to be_success(5)
+
+          expect(m.flatmap{|x| x.sequence(:HL, :HL) }.
+            map{|x| x.count(:HL) }).to be_success(4)
+
+          expect(m.flatmap{|x| x.sequence(:HL, :HL, :HL) }.
+            map{|x| x.count(:HL) }).to be_success(3)
+
+          expect(m.flatmap{|x| x.sequence(:HL, :HL, :HL, :HL) }.
+            map{|x| x.count(:HL) }).to be_success(2)
+
+          expect(m.flatmap{|x| x.sequence(:HL, :HL, :HL, :HL, :HL) }.
+            map{|x| x.count(:HL) }).to be_success(1)
+
+          expect(m.flatmap{|x| x.sequence(:HL, :HL, :HL, :HL, :HL, :HL) }.
+            map{|x| x.count(:HL) }).to be_success(0)
+        end if ss.respond_to?(:permutation)
+      end
+    end
+
+    context "loop-level permutations" do
+      # 837
+      #   Table 1
+      #     1000A NM1*41
+      #     1000B NM1*40
+      let(:dsl) do
+        c = Stupidedi::Config.hipaa
+        b = Stupidedi::Builder::BuilderDsl.build(c, false)
+        b.ISA("00", nil, "01", "SECRET", "ZZ", "SUBMITTER", "ZZ", "RECEIVER", Time.now.utc, Time.now.utc, nil, "00501", 123456789, "1", "T", nil)
+        b. GS("HP", "SENDER", "RECEIVER", Time.now.utc, Time.now.utc, 1, "X", "005010X222")
+        b. ST("837", "0001", b.default)
+          b.BHT("0019", "00", "46X2A6", Time.now.utc, Time.now.utc, "CH")
+
+        b # return BuilderDsl instance
+      end
+
+      specify "NM1*41, NM1*40" do
+        ss = [["41", "2", "TERRIBLE BILLING", nil, nil, nil, nil, "46", "X82BJJ"],
+              ["40", "2", "TERRIBLE INSURAN", nil, nil, nil, nil, "46", "3057XK"]]
+
+        ss.permutation do |p|
+          b = dsl.dup
+          p.each{|es| b.send(:NM1, *es) }
+
+          m = b.machine.parent
+          expect(m.map{|x| x.count(:NM1) }).to be_success(2)
+
+          expect(m.flatmap{|x| x.sequence(:NM1) }.
+            map{|x| x.count(:NM1) }).to be_success(1)
+
+          expect(m.flatmap{|x| x.sequence(:NM1, :NM1) }.
+            map{|x| x.count(:NM1) }).to be_success(0)
+        end if ss.respond_to?(:permutation)
+      end
+    end
+
+    context "segment-level permutations" do
+      # 835
+      #   Table 1
+      #     1000A N1*PR
+      #       PER*CX
+      #       PER*BL
+      #       PER*IC
+
+      let(:dsl) do
+        c = Stupidedi::Config.hipaa
+        b = Stupidedi::Builder::BuilderDsl.build(c)
+        b.ISA("00", nil, "01", "SECRET", "ZZ", "SUBMITTER", "ZZ", "RECEIVER", Time.now.utc, Time.now.utc, nil, "00501", 123456789, "1", "T", nil)
+        b. GS("HP", "SENDER", "RECEIVER", Time.now.utc, Time.now.utc, 1, "X", "005010X221")
+        b. ST("835", "0001")
+          b.BPR("C", 150000, "C", "ACH", "CTX", "01", "999999992", "DA", "123456", "1512345678", nil, "01", "999988880", "DA", "98765", "20020913")
+          b.TRN("1", "12345", "1512345678")
+          b.DTM("405", Time.now.utc)
+          b. N1("PR", "INSURANCE COMPANY OF TIMBUCKTU")
+            b. N3("1 MAIN STREET")
+            b. N4("TIMBUCKTU", "AK", "99501")
+            b.REF("2U", "999")
+            b.REF("NF", "12345")
+
+        b # return BuilderDsl instance
+      end
+
+      specify "PER*IC, PER*BL, PER*CX" do
+        ss = [["IC", nil, "UR", "WEBSITE.COM"],
+              ["BL", "COMPUTER PAT"],
+              ["BL", "COMPUTER SAM"],
+              ["CX", "BUSINESS KIM"]]
+
+        ss.permutation do |p|
+          b = dsl.dup
+          p.each{|es| b.send(:PER, *es) }
+
+          m = b.machine.parent
+          expect(m.map{|x| x.count(:PER) }).to be_success(4)
+
+          expect(m.flatmap{|x| x.sequence(:PER) }.
+            map{|x| x.count(:PER) }).to be_success(3)
+
+          expect(m.flatmap{|x| x.sequence(:PER, :PER) }.
+            map{|x| x.count(:PER) }).to be_success(2)
+
+          expect(m.flatmap{|x| x.sequence(:PER, :PER, :PER) }.
+            map{|x| x.count(:PER) }).to be_success(1)
+
+          expect(m.flatmap{|x| x.sequence(:PER, :PER, :PER, :PER) }.
+            map{|x| x.count(:PER) }).to be_success(0)
+        end if ss.respond_to?(:permutation)
+      end
+    end
+
+  end
+
+  context "X091A1-HP835" do
+
+    it "parses 1-good.txt" do
+      parser = Fixtures.file("X091A1-HP835/1-good.txt")
+      expect(parser).to be_deterministic
+      expect(parser).to be_last
+
+      parser.segment.tap do |iea|
+        expect(iea.node.position.line).to eq(1)
+        expect(iea.node.position.column).to eq(606)
+      end
+
+      expect(parser).to have_sequence(%w(ISA GS ST BPR TRN REF N1 N3 N4 REF PER N1
+        REF LX CLP CAS NM1 PLB SE GE IEA))
+
+      expect(parser).to have_separators(:element => "|", :component => "^",
+        :repetition => nil, :segment => "~")
+
+      parser.parent.tap do |isa|
+        expect(isa).to have_distance(20).to(parser)
+        expect(isa).to have_structure(
+          Ss(X(:ST),
+            R(:ISA), # No more ISAs
+            S(:GS, "HP", "MADE UP CLEARING HOUSE", "611358935", "20130508", nil, "3063") =>
+            Ss(R(:GS), # No more GSs
+                  S(:ST) =>
+                    Ss(R(:ST), # No more STs
+                       S(:BPR, nil, nil) =>
+                         Ss(S(:TRN),
+                            S(:N1, "PR"),
+                            S(:N1, "PE"),
+                            S(:LX, "1"),
+                            S(:PLB),
+                            S(:SE),
+                            S(:GE),
+                            S(:IEA)),
+                       S(:TRN, "1", "74122910359") =>
+                         Ss(X(:BPR)),
+
+                       # 1000A PAYER IDENTIFICATION
+                       S(:N1, "PR", "MADE UP HEALTH CENTER") =>
+                         Ss(S(:N3, "123 FAKE ST."),
+                            S(:N4),
+                            S(:REF, "2U", "80214"),
+                            S(:SE),
+                            S(:GE),
+                            S(:IEA)),
+
+                       # 1000B PAYEE IDENTIFICATION
+                       S(:N1, "PE", nil, "XX", "1386672277") =>
+                         Ss(S(:REF, "TJ"),
+                            S(:SE),
+                            S(:GE),
+                            S(:IEA)),
+
+                       # 2000 HEADER NUMBER
+                       S(:LX, "1") =>
+                         Ss(
+                          S(:CLP) =>
+                            Ss(S(:CAS, "PI", 23, "157.39"),
+                                 S(:NM1, "QC", nil, "DOE"))),
+
+                       S(:PLB, "341491692") =>
+                         Ss(S(:SE, 17, '0001'),
+                            S(:GE, 1, 3063),
+                            S(:IEA, 1, 3063)),
+
+                       S(:SE) => Ss(S(:GE),
+                                    S(:IEA))),
+                  S(:GE)  => Ss(S(:IEA)),
+                  S(:IEA) => Ss())))
+      end
+    end
   end
 
 end