yadtfp 1.0.2

data/spec/outputters_factory_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Yadtfp::OutputtersFactory do
+
+  describe '.create' do
+
+    it 'when :pretty' do
+      expect(Yadtfp::OutputtersFactory.create(:pretty, [])).to be_kind_of(Yadtfp::Outputters::Pretty)
+    end
+
+
+
+
+    it 'when invalid outputter' do
+      expect{ Yadtfp::OutputtersFactory.create('invalid', []) }.to raise_error(ArgumentError)
+    end
+
+  end
+
+end

data/spec/parsers/ox_spec.rb

@@ -0,0 +1,966 @@
+require 'spec_helper'
+
+describe Yadtfp::Parsers::Ox do
+
+  let(:parser) { Yadtfp::Parsers::Ox.new }
+
+
+
+
+  describe '#parse' do
+
+    it 'when xml string is supplied' do
+      xml = %Q{ <xml /> }
+      expect(parser.parse(xml)).to be_kind_of(::Ox::Document)
+    end
+
+
+
+    it 'when file is supplied' do
+      xml = %Q{ <xml /> }
+
+      file = double('dummy')
+      allow(file).to receive(:empty?) { false }
+      allow(File).to receive(:exists?) { true }
+      allow(::Ox).to receive(:load_file) { xml }
+
+      expect(parser.parse('dummy.xml')).to be_kind_of(::Ox::Document)
+    end
+
+
+
+    it 'when inexistent file is supplied' do
+      allow(File).to receive(:exists?) { true }
+      expect { parser.parse('dummy.xml') }.to raise_error(IOError)
+    end
+
+
+
+
+    it 'when nil is supplied' do
+      expect(parser.parse(nil)).to be_kind_of(::Ox::Document)
+    end
+
+
+
+
+    it 'when empty string is supplied' do
+      expect(parser.parse("")).to be_kind_of(::Ox::Document)
+    end
+
+
+
+
+    it 'when invalid xml is supplied' do
+      expect { parser.parse('invalid_xml') }.to raise_error(::Ox::ParseError)
+    end
+
+  end
+
+
+
+
+
+
+  describe '#filter' do
+
+
+    let(:config) { double('Yadtfp::Configuration.instance') }
+
+    before do
+      allow(config).to receive('filter') { '*' }
+    end
+
+
+
+
+    it 'when document is nil' do
+      expect { parser.filter(nil) }.to raise_error ArgumentError
+    end
+
+
+
+
+
+    it 'when filter is default' do
+      doc = ox_parse_doc %Q{ <xml /> }
+      result = [ ::Ox::Element.new('xml') ]
+
+      expect(parser.filter(doc)).to eq result
+    end
+
+
+
+
+
+    it 'when * for single empty node' do
+      doc = ox_parse_doc %Q{ <xml /> }
+      result = [ ::Ox::Element.new('xml') ]
+
+      expect(parser.filter(doc)).to eq result
+    end
+
+
+
+
+
+    it 'when * for multiple empty nodes' do
+      doc = ox_parse_doc %Q{ <xml /><xml /> }
+      result = Array.new(2) { ::Ox::Element.new('xml') }
+
+      expect(parser.filter(doc)).to eq result
+    end
+
+
+
+
+
+
+    it 'when * for nodes with attributes' do
+      doc = ox_parse_doc %Q{ <xml id='root' /> }
+      result = Array.new(1) do
+        elem = ::Ox::Element.new('xml')
+        elem[:id] = 'root'
+        elem
+      end
+
+      expect(parser.filter(doc, "*")).to match_array(result)
+    end
+
+
+
+
+
+    it 'when * for nodes with attributes and comments' do
+      doc = ox_parse_doc %Q{ <xml id='root'><!-- Root node -->Foo</xml> }
+      result = Array.new(1) do
+        elem = ::Ox::Element.new('xml')
+        elem[:id] = 'root'
+        elem << ::Ox::Comment.new('Root node')
+        elem << "Foo"
+      end
+
+      expect(parser.filter(doc, "*")).to eq(result)
+    end
+
+
+
+
+
+    it 'when * for nodes with attributes, comments and cdata' do
+      doc = ox_parse_doc %Q{ <xml id='root'><!-- Root node --><![CDATA[Foo]]>Bar</xml> }
+      result = Array.new(1) do
+        elem = ::Ox::Element.new('xml')
+        elem[:id] = 'root'
+        elem << ::Ox::Comment.new('Root node')
+        elem << ::Ox::CData.new('Foo')
+        elem << "Bar"
+      end
+
+      expect(parser.filter(doc, "*")).to eq(result)
+    end
+
+  end
+
+
+
+
+
+
+
+
+  describe '#diff' do
+
+
+    it 'when left and right are nil' do
+      expect(parser.diff(nil, nil)).to eq []
+    end
+
+
+
+
+
+    it 'when left and right are empty documents' do
+      left = right = ox_parse_doc('')
+
+      expect(parser.diff(left, right)).to eq []
+    end
+
+
+
+
+
+    it 'when left is nil' do
+      right = ox_parse_doc('')
+
+      diff = right.attributes.values
+      expect(parser.diff(nil, right)).to eq diff
+    end
+
+
+
+
+
+    it 'when right is nil' do
+      left = ox_parse_doc('')
+
+      diff = left.attributes.values
+      expect(parser.diff(left, nil)).to eq diff
+    end
+
+
+
+
+
+    it 'when left and right have different attributes' do
+      left = ox_parse_doc %Q{ <xml id='root' /> }
+      right = ox_parse_doc %Q{ <xml name='root_node' /> }
+
+      diff = [
+        { type: 'd', path: '/xml/@id', lvalue: 'root', rvalue: nil },
+        { type: 'a', path: '/xml/@name', lvalue: nil, rvalue: 'root_node' }
+      ]
+      expect(parser.diff(left, right)).to eq diff
+    end
+
+
+
+
+
+    it 'when left has children and right does not' do
+      left_xml = %{
+        <xml>
+          <node>Child</node>
+        </xml>
+      }
+      left = ox_parse_doc(left_xml)
+      right = ox_parse_doc("<xml />")
+
+      diff = [
+        { type: 'd', path: '/xml/node', lvalue: 'Child', rvalue: nil }
+      ]
+
+      expect(parser.diff(left, right)).to eq diff
+    end
+
+
+
+
+
+
+    it 'when right has children and left does not' do
+      right_xml = %{
+        <xml>
+          <node>Child</node>
+        </xml>
+      }
+      left = ox_parse_doc('<xml />')
+      right = ox_parse_doc(right_xml)
+
+      diff = [
+        { type: 'a', path: '/xml/node', lvalue: nil, rvalue: 'Child' }
+      ]
+
+      expect(parser.diff(left, right)).to eq diff
+
+    end
+
+
+
+
+
+
+    it 'when left has more number of children than right' do
+      left = ox_parse_doc %{
+        <xml>
+          <node>First</node>
+          <node>Second</node>
+        </xml>
+      }
+      right = ox_parse_doc %{
+        <xml>
+          <node>Right first</node>
+        </xml>
+      }
+
+
+      diff = [
+        { type: 'c', path: '/xml/node', lvalue: [ 'First', 'Second' ], rvalue: 'Right first' },
+      ]
+
+      expect(parser.diff(left, right)).to eq diff
+    end
+
+
+
+
+
+    it 'when left has same number of children as right' do
+      left = ox_parse_doc %{
+        <xml>
+          <node>First</node>
+          <node>Second</node>
+        </xml>
+      }
+      right = ox_parse_doc %{
+        <xml>
+          <node>Right first</node>
+          <node>Right second</node>
+        </xml>
+      }
+
+
+      diff = [
+        { type: 'c', path: '/xml/node', lvalue: [ 'First', 'Second' ], rvalue: [ 'Right first', 'Right second' ] }
+      ]
+
+      expect(parser.diff(left, right)).to eq diff
+    end
+
+
+
+
+
+    it 'when left has same number of same text children as right' do
+      left = ox_parse_doc %{
+        <xml>
+          <node>First</node>
+          <node>Second</node>
+        </xml>
+      }
+      right = ox_parse_doc %{
+        <xml>
+          <node>First</node>
+          <node>Second</node>
+        </xml>
+      }
+
+
+      diff = []
+
+      expect(parser.diff(left, right)).to eq diff
+    end
+
+
+
+
+
+    it 'when left has children with different comments and text than right' do
+      left = ox_parse_doc %Q{
+        <xml>
+          <node><![CDATA[Foo]]><!-- Foo -->First child</node>
+        </xml>
+      }
+
+      right = ox_parse_doc %Q{
+        <xml>
+          <node><![CDATA[Foo]]><!-- Bar -->Second child<!-- Baz --></node>
+        </xml>
+      }
+
+
+      diff = [
+        { type: 'c', path: '/xml/node/comment()', lvalue: [ 'Foo' ], rvalue: [ 'Bar', 'Baz' ] },
+        { type: 'c', path: '/xml/node', lvalue: 'First child', rvalue: 'Second child' }
+      ]
+
+
+      expect(parser.diff(left, right)).to eq diff
+    end
+
+
+
+
+
+
+    it 'when left has children with same comments and text as right' do
+      left = ox_parse_doc %Q{
+        <xml>
+          <node><![CDATA[Foo]]><!-- Foo -->Child<!-- Bar --></node>
+        </xml>
+      }
+
+      right = ox_parse_doc %Q{
+        <xml>
+          <node><![CDATA[Foo]]><!-- Foo -->Child<!-- Bar --></node>
+        </xml>
+      }
+
+
+      expect(parser.diff(left, right)).to eq []
+    end
+
+
+
+
+
+    it 'when right hash more children than left' do
+      left = ox_parse_doc %Q{
+        <xml>
+          <node>a</node>
+          <node>b</node>
+          <node>c</node>
+        </xml>
+      }
+
+      right = ox_parse_doc %Q{
+        <xml>
+          <node>a</node>
+          <node>b</node>
+          <node>c</node>
+          <node>d</node>
+        </xml>
+      }
+      diff =  [ { type: 'a', path: '/xml/node', lvalue: nil, rvalue: [ 'd' ] } ]
+
+
+      expect(parser.diff(left, right)).to eq(diff)
+    end
+
+
+
+
+
+    it 'when left has more number than right of same values' do
+      left = ox_parse_doc %Q{
+        <xml>
+          <node>a</node>
+          <node>a</node>
+          <node>a</node>
+        </xml>
+      }
+
+      right = ox_parse_doc %Q{
+        <xml>
+          <node>a</node>
+          <node>a</node>
+        </xml>
+      }
+      diff = [ { type: 'd', path: '/xml/node', lvalue: [ 'a' ], rvalue: nil } ]
+
+      expect(parser.diff(left, right)).to eq(diff)
+    end
+
+
+
+
+
+    it 'when right has more number than left of same values' do
+      left = ox_parse_doc %Q{
+        <xml>
+          <node>a</node>
+          <node>a</node>
+        </xml>
+      }
+
+      right = ox_parse_doc %Q{
+        <xml>
+          <node>a</node>
+          <node>a</node>
+          <node>a</node>
+        </xml>
+      }
+      diff = [ { type: 'a', path: '/xml/node', lvalue: nil, rvalue: [ 'a' ] } ]
+
+      expect(parser.diff(left, right)).to eq(diff)
+    end
+
+
+
+
+
+    it 'when left and right are empty arrays' do
+      expect(parser.diff([], [])).to eq []
+    end
+
+
+  end
+
+
+
+
+
+
+
+  describe '#flat_h' do
+
+
+    describe '::Ox::Document' do
+
+      it 'when document is nil' do
+        expect(parser.flat_h(nil)).to be_nil
+      end
+
+
+
+
+      it 'when document is empty' do
+        xml = ox_parse_doc('')
+        result = { '/@version' => '1.0', '/@encoding' => 'UTF-8' }
+
+        expect(parser.flat_h(xml)).to eq(result)
+      end
+
+
+
+
+      it 'when document has a comment' do
+        xml = %Q{
+          <!-- Comment -->
+        }
+        xml = ox_parse_doc(xml)
+        result = { '/@version' => '1.0', '/@encoding' => 'UTF-8', '/comment()' => [ 'Comment' ] }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+      it 'when document has an empty root node' do
+        xml = ox_parse_doc %Q{ <foo /> }
+
+        result = { '/@version' => '1.0', '/@encoding' => 'UTF-8', '/foo' => nil }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+      it 'when document has root node with attributes' do
+        xml = ox_parse_doc %Q{ <foo id='root' /> }
+
+        result = { '/@version' => '1.0', '/@encoding' => 'UTF-8', '/foo/@id' => 'root' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when document has root node with multiple attributes' do
+        xml = ox_parse_doc %Q{ <foo id='root' name='root_node' /> }
+
+        result = { '/@version' => '1.0', '/@encoding' => 'UTF-8', '/foo/@id' => 'root', '/foo/@name' => 'root_node' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when document has root node with attributes and comment' do
+        xml = ox_parse_doc %Q{ <foo id='root'><!-- Foo's comment --></foo> }
+
+        result = { '/@version' => '1.0',
+                   '/@encoding' => 'UTF-8',
+                   '/foo/@id' => 'root',
+                   '/foo/comment()' => [ "Foo's comment" ] }
+
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+      it 'when document has root node with attributes and multiple comments' do
+        xml = ox_parse_doc %Q{ <foo id='root'><!-- Foo --><!-- Bar --></foo> }
+
+        result = { '/@version' => '1.0',
+                   '/@encoding' => 'UTF-8',
+                   '/foo/@id' => 'root',
+                   '/foo/comment()' => [ 'Foo', 'Bar' ] }
+
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+      it 'when document has root node with text' do
+        xml = ox_parse_doc %Q{ <foo>Foo</foo> }
+
+        result = { '/@version' => '1.0',
+                   '/@encoding' => 'UTF-8',
+                   '/foo' => 'Foo' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+      it 'when document has root node with attributes and text' do
+        xml = ox_parse_doc %Q{ <foo id='foo' name='root_node'>Foo</foo> }
+
+        result = { '/@version' => '1.0',
+                   '/@encoding' => 'UTF-8',
+                   '/foo' => 'Foo',
+                   '/foo/@id' => 'foo',
+                   '/foo/@name' => 'root_node' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+      it 'when document has root node with attributes, comment and text' do
+        xml = ox_parse_doc %Q{ <foo id='foo'><!-- Foo's comment -->Foo</foo> }
+
+        result = { '/@version' => '1.0',
+                   '/@encoding' => 'UTF-8',
+                   '/foo' => 'Foo',
+                   '/foo/comment()' => [ "Foo's comment" ],
+                   '/foo/@id' => 'foo' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+      it 'when document has root node with attributes, multiple comments and text' do
+        xml = ox_parse_doc %Q{ <foo id='foo'><!-- Foo's comment -->Foo<!-- Second comment --></foo> }
+
+        result = { '/@version' => '1.0',
+                   '/@encoding' => 'UTF-8',
+                   '/foo' => 'Foo',
+                   '/foo/comment()' => [ "Foo's comment", "Second comment" ],
+                   '/foo/@id' => 'foo' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+      it 'when document has root node with attributes, multiple comments and multiple text' do
+        xml = ox_parse_doc %Q{ <foo id='foo'><!-- Foo's comment -->Foo<!-- Second comment -->Bar</foo> }
+
+        result = { '/@version' => '1.0',
+                   '/@encoding' => 'UTF-8',
+                   '/foo' => [ 'Foo', 'Bar' ],
+                   '/foo/comment()' => [ "Foo's comment", "Second comment" ],
+                   '/foo/@id' => 'foo' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+    end
+
+
+
+
+
+    describe '::Ox::Element' do
+
+      it 'when element is nil' do
+        expect(parser.flat_h(nil)).to eq nil
+      end
+
+
+
+
+      it 'when empty element' do
+        xml = ox_parse_elem %Q{ <xml /> }
+        result = { '/xml' => nil }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has a comment' do
+        xml = ox_parse_elem %Q{ <xml><!-- Foo --></xml> }
+        result = { '/xml/comment()' => [ 'Foo' ] }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has attribute' do
+        xml = ox_parse_elem %Q{ <xml id='root' /> }
+        result = { '/xml/@id' => 'root' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has multiple attributes' do
+        xml = ox_parse_elem %Q{ <xml id='root' name='foo' /> }
+        result = { '/xml/@id' => 'root', '/xml/@name' => 'foo' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has attributes and comment' do
+        xml = ox_parse_elem %Q{ <xml id='root' name='Root'><!-- Root node --></xml> }
+        result = { '/xml/@id' => 'root',
+                   '/xml/@name' => 'Root',
+                   '/xml/comment()' => [ 'Root node' ] }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has text' do
+        xml = ox_parse_elem %Q{ <xml>Foo</xml> }
+        result = { '/xml' => 'Foo' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has a text and a comment' do
+        xml = ox_parse_elem %Q{ <xml><!-- Comment -->Foo</xml> }
+        result = { '/xml/comment()' => [ 'Comment' ], '/xml' => 'Foo' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has comment around text' do
+        xml = ox_parse_elem %Q{ <xml><!-- Comment one -->Foo<!-- Comment two --></xml> }
+        result = { '/xml' => 'Foo', '/xml/comment()' => [ 'Comment one', 'Comment two' ] }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has multiple comments and multiple texts' do
+        xml = ox_parse_elem %Q{ <xml><!-- Comment one -->Foo<!-- Comment two -->Bar</xml> }
+        result = { '/xml' => [ 'Foo', 'Bar' ], '/xml/comment()' => [ 'Comment one', 'Comment two' ] }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has attributes, comments and text' do
+        xml = ox_parse_elem %Q{ <xml id='root' name='root_node'><!-- Root node -->Foo</xml> }
+        result = { '/xml' => 'Foo',
+                   '/xml/@id' => 'root',
+                   '/xml/@name' => 'root_node',
+                   '/xml/comment()' => [ 'Root node' ] }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has an empty child' do
+        xml = ox_parse_elem %Q{ <foo><bar /></foo> }
+        result = { '/foo/bar' => nil }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has a child with attributes' do
+        xml = ox_parse_elem %Q{ <foo><bar id='child' /></foo> }
+        result = { '/foo/bar/@id' => 'child' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has a child with attributes and text' do
+        xml = ox_parse_elem %Q{ <foo><bar id='child'>Child</bar></foo> }
+        result = { '/foo/bar/@id' => 'child', '/foo/bar' => 'Child' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has child with attributes, text and comment' do
+        xml = ox_parse_elem %Q{ <foo><bar id='child' name='child_node'><!-- Child -->Child</bar></foo> }
+        result = { '/foo/bar/@id' => 'child',
+                   '/foo/bar/@name' => 'child_node',
+                   '/foo/bar/comment()' => [ 'Child' ],
+                   '/foo/bar' => 'Child' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has children with attributes, text and comment' do
+        xml = ox_parse_elem %Q{
+          <foo>
+            <bar id='first' name='first_child'><!-- First child -->First child</bar>
+            <bar id='second' name='second_child'><!-- Second child -->Second child</bar>
+          </foo>
+        }
+        result = {
+          '/foo/bar/@id' => [ 'first', 'second' ],
+          '/foo/bar/@name' => [ 'first_child', 'second_child' ],
+          '/foo/bar/comment()' => [ [ 'First child' ], [ 'Second child' ] ],
+          '/foo/bar' => [ 'First child', 'Second child' ]
+        }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has attributes, comments and children with attributes text and comment' do
+        xml = ox_parse_elem %Q{
+          <foo id='root' name='root_node'>
+            <!-- Root node -->
+            <bar id='first' name='first_child'><!-- First child -->First child</bar>
+            <bar id='second' name='second_child'><!-- Second child -->Second child</bar>
+          </foo>
+        }
+        result = {
+          '/foo/@id' => 'root',
+          '/foo/@name' => 'root_node',
+          '/foo/comment()' => [ 'Root node' ],
+          '/foo/bar/@id' => [ 'first', 'second' ],
+          '/foo/bar/@name' => [ 'first_child', 'second_child' ],
+          '/foo/bar/comment()' => [ [ 'First child' ], [ 'Second child' ] ],
+          '/foo/bar' => [ 'First child', 'Second child' ]
+        }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has cdata' do
+        xml = ox_parse_elem %Q{ <foo><![CDATA[Foo]]></foo> }
+        result = { '/foo/cdata()' => [ 'Foo' ] }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has text and cdata' do
+        xml = ox_parse_elem %Q{ <foo><![CDATA[Foo]]>Foo Text</foo> }
+        result = { '/foo/cdata()' => [ 'Foo' ], '/foo' => 'Foo Text' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has multiple text and multiple cdata' do
+        xml = ox_parse_elem %Q{ <foo><![CDATA[Foo]]>First Text<![CDATA[Bar]]>Second Text</foo> }
+        result = { '/foo/cdata()' => [ 'Foo', 'Bar' ], '/foo' => [ 'First Text', 'Second Text' ] }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has text, cdata and attributes' do
+        xml = ox_parse_elem %Q{ <foo id='foo'><![CDATA[Foo]]>Foo</foo> }
+        result = { '/foo/@id' => 'foo', '/foo/cdata()' => [ 'Foo' ], '/foo' => 'Foo' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+      it 'when element has text, cdata, attributes and comments' do
+        xml = ox_parse_elem %Q{ <foo id='foo'><![CDATA[Foo]]>Foo<!-- Foo's Comment --></foo> }
+        result = { '/foo/@id' => 'foo',
+                   '/foo/cdata()' => [ 'Foo' ],
+                   '/foo/comment()' => [ "Foo's Comment" ],
+                   '/foo' => 'Foo' }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+
+
+
+
+      it 'when element has attributes, comments, cdata and children with attributes text, comment and cdata' do
+        xml = ox_parse_elem %Q{
+          <foo id='root' name='root_node'>
+            <!-- Root node -->
+            <![CDATA[Foo]]>
+            <bar id='first' name='first_child'><!-- First child -->First child<![CDATA[Foo]]></bar>
+            <bar id='second' name='second_child'><!-- Second child -->Second child<![CDATA[Bar]]></bar>
+          </foo>
+        }
+        result = {
+          '/foo/@id' => 'root',
+          '/foo/@name' => 'root_node',
+          '/foo/comment()' => [ 'Root node' ],
+          '/foo/cdata()' => [ 'Foo' ],
+          '/foo/bar/@id' => [ 'first', 'second' ],
+          '/foo/bar/@name' => [ 'first_child', 'second_child' ],
+          '/foo/bar/comment()' => [ [ 'First child' ], [ 'Second child' ] ],
+          '/foo/bar/cdata()' => [ [ 'Foo' ], [ 'Bar' ] ],
+          '/foo/bar' => [ 'First child', 'Second child' ]
+        }
+
+        expect(parser.flat_h(xml)).to eq result
+      end
+
+
+    end
+
+  end
+
+end