stupidedi 1.1.0

data/spec/examples/integration/navigating.example

@@ -0,0 +1,214 @@
+require "spec_helper"
+
+describe "Navigating" do
+  include NavigationMatchers
+
+  let(:payment) { Fixtures.file("X221-HP835/1-good.txt").first  }
+  let(:claim)   { Fixtures.file("X222-HC837/3b-good.txt").first }
+
+  context "unqualified segments" do
+  end
+
+  context "qualified segments" do
+  end
+
+  context "sequence of segments" do
+  end
+
+  context "parent segments" do
+    specify "the first ISA is a root" do
+      # ISA has no parent segment
+      payment.flatmap(&:parent).should_not be_defined
+    end
+
+    specify "the second ISA's parent is the first ISA" do
+      payment.flatmap do |isa|
+        isa.last.tap do |iea|
+          b = Stupidedi::Builder::BuilderDsl.new(iea, false)
+          b.ISA("00", "",
+                "00", "",
+                "ZZ", "",
+                "ZZ", "",
+                Time.now.utc,
+                Time.now.utc,
+                "", "00501", 123456789, "1", "T", "")
+
+          # The ISA segment we just added has the first ISA for a dad
+          b.machine.should have_parent(isa)
+        end
+      end
+    end
+  end
+
+  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
+    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 \
+          raise_error("ISA segment has only 16 elements")
+      end
+
+      it "raises an exception" do
+        lambda { payment.tap{|isa| isa.element(0) }}.should \
+          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|
+          # non-strict builder used to append a bad segment (ISA version)
+          b = Stupidedi::Builder::BuilderDsl.new(iea, false)
+          b.ISA("00", "",
+                "00", "",
+                "ZZ", "",
+                "ZZ", "",
+                Time.now.utc,
+                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
+      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 \
+          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 \
+          raise_error("ISA01 is a simple element")
+      end
+    end
+  end
+
+  describe "simple elements" 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 \
+          be_defined
+      end
+
+      specify do
+        payment.flatmap(&:zipper).tap do |z|
+          # z is a zipper pointing to SegmentVal[ISA]
+          z.node.id.should == :ISA
+        end
+      end
+
+      it "is equivalent to using the state machine" do
+        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)) }
+          end
+        end.should be_defined
+
+        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)) }
+          end
+        end.should 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
+      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
+      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
+      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
+      end
+    end
+
+    context "fixed precision numeric elements" do
+    end
+
+    context "floating precision numeric elements" do
+    end
+  end
+
+  context "composite elements" do
+  end
+
+  context "repeated simple elements" do
+  end
+
+  context "repeated composite elements" do
+  end
+
+end

data/spec/examples/integration/parsing.example

@@ -0,0 +1,445 @@
+require "spec_helper"
+
+describe "Parsing" do
+  include NavigationMatchers
+
+  context "X222-HC837" do
+    let(:parser) { Fixtures.file("X222-HC837/1-good.txt") }
+
+    it "parses 1-good.txt" do
+      parser.should be_deterministic
+      parser.should be_last
+
+      parser.segment.tap do |iea|
+        iea.node.position.line.should   == 53
+        iea.node.position.column.should == 1
+      end
+
+      parser.should 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 => ":",
+                                    :repetition => "^", :segment => "~")
+
+      parser.parent.tap do |isa|
+        # Should have 49 total segments in the parse tree
+        isa.should have_distance(48).to(parser)
+
+        # See matchers/navigation_matchers.rb
+        #
+        # Ss: list of segment matchers
+        #  C: composite element
+        #
+        #  S: the segment might be reachable, and /is/ reachable
+        #  R: the segment might be reachable, but didn't occur
+        #  X: the segment would never be reachable
+        #
+        isa.should have_structure(
+          Ss(X(:ST),
+             R(:ISA), # No more ISAs
+             S(:GS, "HC", nil, nil, nil, nil, 1) =>
+               Ss(R(:GS), # No more GSs
+                  S(:ST) =>
+                    Ss(R(:ST), # No more STs
+                       X(:PRV),
+                       X(:NM1, "85"),
+                       X(:NM1, "87"),
+                       X(:SBR),
+                       X(:NM1, "IL"),
+                       X(:NM1, "PR"),
+                       S(:BHT) =>
+                         Ss(S(:NM1, "41"),
+                            S(:NM1, "40"),
+                            S(:HL, "1"),
+                            S(:HL, "2"),
+                            S(:HL, "3"),
+                            S(:SE),
+                            S(:GE),
+                            S(:IEA)),
+                       # 1000A SUBMITTER NAME
+                       S(:NM1, "41") =>
+                         Ss(S(:PER),
+                            S(:NM1, "40"),
+                            S(:HL,  "1"),
+                            S(:HL,  "2"),
+                            S(:HL,  "3"),
+                            S(:SE),
+                            S(:GE),
+                            S(:IEA)),
+                       # 1000B RECEIVER NAME
+                       S(:NM1, "40") =>
+                         Ss(S(:HL, "1"),
+                            S(:HL, "2"),
+                            S(:HL, "3"),
+                            S(:SE),
+                            S(:GE),
+                            S(:IEA)),
+                       # 2000A BILLING PROVIDER HIERARCHICAL LEVEL
+                       S(:HL, "1") =>
+                         Ss(S(:PRV) =>
+                              Ss(S(:NM1, "85"),
+                                 S(:NM1, "87"),
+                                 S(:HL, "2"),
+                                 S(:HL, "3"),
+                                 S(:SE),
+                                 S(:GE),
+                                 S(:IEA)),
+                            # 2010AA BILLING PROVIDER NAME
+                            S(:NM1, "85") =>
+                              Ss(S(:NM1, "87") => Ss(),
+                                 S(:N3)        => Ss(S(:N4),
+                                                     S(:REF, "EI"),
+                                                     S(:NM1, "87")),
+                                 S(:N4)        => Ss(S(:REF, "EI"),
+                                                     S(:NM1, "87")),
+                                 S(:REF, "EI") => Ss(S(:NM1, "87")),
+                                 S(:SE)        => Ss(),
+                                 S(:GE)        => Ss(),
+                                 S(:IEA)       => Ss()),
+                            # 2010AB PAY-TO ADDRESS NAME
+                            S(:NM1, "87") =>
+                              Ss(S(:N3)  => Ss(S(:N4),
+                                               S(:HL, "2")),
+                                 S(:N4)  => Ss(S(:HL, "2")),
+                                 S(:SE)  => Ss(),
+                                 S(:GE)  => Ss(),
+                                 S(:IEA) => Ss()),
+                            S(:HL, "2") => Ss(),
+                            S(:HL, "3") => Ss(),
+                            S(:SE)      => Ss(),
+                            S(:GE)      => Ss(),
+                            S(:IEA)     => Ss()),
+                         # 2000B SUBSCRIBER HIERARCHICAL LEVEL
+                         S(:HL, "2") =>
+                           Ss(S(:SBR) =>
+                                Ss(S(:NM1, "IL"),
+                                   S(:NM1, "PR"),
+                                   S(:HL, "3"),
+                                   S(:SE),
+                                   S(:GE),
+                                   S(:IEA)),
+                              # 2010BA SUBSCRIBER NAME
+                              S(:NM1, "IL") =>
+                                Ss(S(:N3)  => Ss(S(:N4),
+                                                 S(:DMG),
+                                                 S(:NM1, "PR"),
+                                                 S(:HL, "3")),
+                                   S(:N4)  => Ss(S(:DMG),
+                                                 S(:NM1, "PR"),
+                                                 S(:HL, "3")),
+                                   S(:DMG) => Ss(S(:NM1, "PR"),
+                                                 S(:HL, "3")),
+                                   S(:SE)  => Ss(),
+                                   S(:GE)  => Ss(),
+                                   S(:IEA) => Ss()),
+                              # 2010BB PAYER NAME
+                              S(:NM1, "PR") =>
+                                Ss(S(:N4) => Ss(S(:REF, "G2"),
+                                                S(:HL, "3")),
+                                   S(:REF, "G2") => Ss(S(:HL, "3")),
+                                   S(:SE)        => Ss(),
+                                   S(:GE)        => Ss(),
+                                   S(:IEA)       => Ss()),
+                              S(:HL, "3") => Ss(),
+                              S(:SE)      => Ss(),
+                              S(:GE)      => Ss(),
+                              S(:IEA)     => Ss()),
+                         # 2000C PATIENT HIERARCHICAL LEVEL
+                         S(:HL, "3") =>
+                           Ss(S(:PAT) => Ss(S(:NM1, "QC"),
+                                            S(:CLM),
+                                            S(:SE),
+                                            S(:GE),
+                                            S(:IEA)),
+                              # 2010CA PATIENT NAME
+                              S(:NM1, "QC") =>
+                                Ss(S(:N3)  => Ss(S(:N4),
+                                                 S(:DMG),
+                                                 S(:CLM)),
+                                   S(:N4)  => Ss(S(:DMG),
+                                                 S(:CLM)),
+                                   S(:DMG) => Ss(S(:CLM)),
+                                   S(:CLM) => Ss(),
+                                   S(:SE)  => Ss(),
+                                   S(:GE)  => Ss(),
+                                   S(:IEA) => Ss()),
+                              # 2300 CLAIM INFORMATION
+                              S(:CLM) =>
+                                Ss(R(:CLM), # No more CLMs
+                                   S(:REF, "D9"),
+                                   S(:HI, C("BK", "0340"), C("BF", "V7389")),
+                                   # 2400 SERVICE LINE NUMBER
+                                   S(:LX, "1") =>
+                                     Ss(R(:LX, "1"), # No more LX*1's
+                                        S(:LX, "2"),
+                                        S(:LX, "3"),
+                                        S(:LX, "4"),
+                                        S(:SV1, C(nil, "99213")) => Ss(S(:DTP, "472"),
+                                                                       S(:LX, "2"),
+                                                                       S(:LX, "3"),
+                                                                       S(:LX, "4"),
+                                                                       S(:SE),
+                                                                       S(:GE),
+                                                                       S(:IEA)),
+                                        S(:DTP, "472") => Ss(S(:LX, "2"),
+                                                             S(:LX, "3"),
+                                                             S(:LX, "4"),
+                                                             S(:SE),
+                                                             S(:GE),
+                                                             S(:IEA))),
+                                   # 2400 SERVICE LINE NUMBER
+                                   S(:LX, "2") =>
+                                     Ss(R(:LX, "1"),
+                                        R(:LX, "2"), # No more LX*2's
+                                        S(:LX, "3"),
+                                        S(:LX, "4"),
+                                        S(:SV1, C(nil, "87070")) => Ss(S(:DTP, "472"),
+                                                                       S(:LX, "3"),
+                                                                       S(:LX, "4"),
+                                                                       S(:SE),
+                                                                       S(:GE),
+                                                                       S(:IEA)),
+                                        S(:DTP, "472") => Ss(S(:LX, "3"),
+                                                             S(:LX, "4"),
+                                                             S(:SE),
+                                                             S(:GE),
+                                                             S(:IEA))),
+                                   # 2400 SERVICE LINE NUMBER
+                                   S(:LX, "3") =>
+                                     Ss(R(:LX, "1"), # No more LX*1's
+                                        R(:LX, "2"), # No more LX*2's
+                                        R(:LX, "3"), # No more LX*3's
+                                        S(:LX, "4"),
+                                        S(:SV1, C(nil, "99214")) => Ss(S(:DTP, "472"),
+                                                                       S(:LX, "4"),
+                                                                       S(:SE),
+                                                                       S(:GE),
+                                                                       S(:IEA)),
+                                        S(:DTP, "472") => Ss(S(:LX, "4"),
+                                                             S(:SE),
+                                                             S(:GE),
+                                                             S(:IEA))),
+                                   # 2400 SERVICE LINE NUMBER
+                                   S(:LX, "4") =>
+                                     Ss(R(:LX, "1"),
+                                        R(:LX, "2"),
+                                        R(:LX, "3"),
+                                        R(:LX, "4"),
+                                        S(:SV1, C(nil, "86663")) => Ss(S(:DTP, "472"),
+                                                                       S(:SE),
+                                                                       S(:GE),
+                                                                       S(:IEA)),
+                                        S(:DTP, "472") => Ss(S(:SE),
+                                                             S(:GE),
+                                                             S(:IEA))))),
+                       S(:SE) => Ss(S(:GE),
+                                    S(:IEA))),
+                  S(:GE)  => Ss(S(:IEA)),
+                  S(:IEA) => Ss())))
+      end
+    end
+  end
+
+  context "X221-HP835" do
+
+    it "parses 1-good.txt" do
+      parser = Fixtures.file("X221-HP835/1-good.txt")
+      parser.should be_deterministic
+      parser.should be_last
+
+      parser.segment.tap do |iea|
+        iea.node.position.line.should   == 40
+        iea.node.position.column.should == 1
+      end
+
+      parser.should 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 => ">",
+                                    :repetition => "~", :segment => "\r")
+
+      parser.parent.tap do |isa|
+        isa.should have_distance(35).to(parser)
+
+        # See matchers/navigation_matchers.rb
+        #
+        # Ss: list of segment matchers
+        #  C: composite element
+        #
+        #  S: the segment might be reachable, and /is/ reachable
+        #  R: the segment might be reachable, but didn't occur
+        #  X: the segment would never be reachable
+        #
+        isa.should have_structure(
+          Ss(X(:ST),
+             R(:ISA), # No more ISAs
+             S(:GS, "HP", nil, nil, "19991231", nil, 1) =>
+               Ss(R(:GS), # No more GSs
+                  S(:ST) =>
+                    Ss(R(:ST), # No more STs
+                       S(:BPR, nil, 150000) =>
+                         Ss(S(:TRN),
+                            S(:DTM),
+                            S(:N1, "PR"),
+                            S(:N1, "PE"),
+                            S(:LX, "110212"),
+                            S(:LX, "130212"),
+                            S(:PLB),
+                            S(:SE),
+                            S(:GE),
+                            S(:IEA)),
+                       S(:TRN, "1", "12345") =>
+                         Ss(X(:BPR)),
+
+                       S(:DTM, "405", Date.civil(2002, 9, 13)) =>
+                         Ss(X(:TRN)),
+
+                       # 1000A PAYER IDENTIFICATION
+                       S(:N1, "PR", "INSURANCE COMPANY OF TIMBUCKTU") =>
+                         Ss(S(:N3, "1 MAIN STREET"),
+                            S(:N4),
+                            S(:REF, "2U", "999"),
+                            S(:REF, "NF", "12345"),
+                            S(:SE),
+                            S(:GE),
+                            S(:IEA)),
+
+                       # 1000B PAYEE IDENTIFICATION
+                       S(:N1, "PE", nil, "XX", "1232343560") =>
+                         Ss(S(:REF, "TJ"),
+                            S(:SE),
+                            S(:GE),
+                            S(:IEA)),
+
+                       # 2000 HEADER NUMBER
+                       S(:LX, "110212") =>
+                         Ss(S(:LX, "130212"),
+                            S(:TS3),
+                            S(:TS2),
+                            S(:CLP) =>
+                              Ss(S(:CAS, "CO", 45, "73348.57"),
+                                 S(:NM1, "QC", nil, "JONES"),
+                                 S(:MIA, 0, nil, nil, "138018.4".to_d),
+                                 S(:DTM, "232", "20020816"),
+                                 S(:DTM, "233", "20020824"),
+                                 S(:AMT, "AU", 150000),
+                                 S(:QTY, "CA", 8))),
+
+                       # 2000 HEADER NUMBER
+                       S(:LX, "130212") =>
+                         Ss(R(:LX, "110212"),
+                            S(:TS3, "6543210909", "13", "1996/12/31", 1, 15000),
+                            S(:CLP, "777777") =>
+                              Ss(S(:CAS, "CO", "45", "3019.67"),
+                                 S(:NM1, "QC"),
+                                 S(:MOA, nil, nil, "MA02"),
+                                 S(:DTM, "232", "2002-05-12"),
+                                 S(:AMT, "AU", 17000))),
+
+                       S(:PLB, "6543210903") =>
+                         Ss(S(:SE, 32, 1234),
+                            S(:GE, 1, 1),
+                            S(:IEA, 1, 905)),
+                       S(:PLB, nil, "20021231") =>
+                         Ss(S(:SE, "32", "1234"),
+                            S(:GE, "1", "1"),
+                            S(:IEA, "1", "905")),
+                       S(:PLB, nil, nil, C("CV", "CP")) => Ss(),
+                       S(:PLB, nil, nil, nil, "-1.27")  => Ss(),
+
+                       S(:SE) => Ss(S(:GE),
+                                    S(:IEA))),
+                  S(:GE)  => Ss(S(:IEA)),
+                  S(:IEA) => Ss())))
+      end
+    end
+
+    context "issues with Table 3 (Summary)" do
+      it "handles missing PLB" do
+        parser = Fixtures.file("X221-HP835/2-good.txt")
+        parser.should be_deterministic
+
+        parser.parent.tap do |isa|
+          isa.should have_structure(
+            Ss(X(:SE),
+               X(:PLB),
+               S(:GS, "HP", nil, nil, "19991231", nil, 1) =>
+                 Ss(X(:SE),
+                    X(:PLB),
+                    S(:ST) =>
+                      Ss(R(:PLB),
+                         S(:LX) =>
+                           Ss(S(:SE),
+                              R(:PLB)),
+                         S(:SE) =>
+                           Ss(X(:PLB),
+                              X(:SE))))))
+        end
+      end
+
+      it "handles single PLB" do
+        parser = Fixtures.file("X221-HP835/1-good.txt")
+        parser.should be_deterministic
+
+        parser.parent.tap do |isa|
+          isa.should have_structure(
+            Ss(X(:SE),
+               X(:PLB),
+               S(:GS, "HP", nil, nil, "19991231", nil, 1) =>
+                 Ss(X(:SE),
+                    X(:PLB),
+                    S(:ST) =>
+                      Ss(S(:LX) =>
+                           Ss(S(:SE),
+                              S(:PLB)),
+                         S(:SE) =>
+                           Ss(X(:PLB),
+                              X(:SE)),
+                         S(:PLB) =>
+                           Ss(R(:PLB), # only one PLB
+                              S(:SE))))))
+        end
+      end
+
+      it "handles multiple PLBs" do
+        parser = Fixtures.file("X221-HP835/3a-good.txt")
+        parser.should be_deterministic
+
+        parser.parent.tap do |isa|
+          isa.should have_structure(
+            Ss(X(:SE),
+               X(:PLB),
+               S(:GS, "HP", nil, nil, "19991231", nil, 1) =>
+                 Ss(X(:SE),
+                    X(:PLB),
+                    S(:ST) =>
+                      Ss(S(:LX) =>
+                           Ss(S(:SE),
+                              S(:PLB),
+                              S(:PLB, "9876543210"),
+                              S(:PLB, "0123456789")),
+                         S(:SE) =>
+                           Ss(X(:PLB),
+                              X(:SE)),
+                         S(:PLB) =>
+                           Ss(S(:PLB),
+                              S(:PLB, "0123456789"),
+                              R(:PLB, "9876543210"),
+                              S(:SE)),
+                         S(:PLB, "0123456789") =>
+                           Ss(R(:PLB, "0123456789"),
+                              R(:PLB, "9876543210"),
+                              S(:SE)),
+                         S(:PLB, "9876543210") =>
+                           Ss(R(:PLB, "9876543210"),
+                              S(:PLB, "0123456789"),
+                              S(:SE))))))
+        end
+      end
+    end
+
+  end
+
+end