yamlr 2.0.0

data/test/test_reader_format.rb

@@ -0,0 +1,393 @@
+#!/usr/bin/env ruby -w
+
+require 'rubygems'
+require 'minitest/unit'
+$: << 'lib' << 'test'
+require 'yamlr/reader/format'
+require 'yamlr/defaults'
+MiniTest::Unit.autorun
+
+class TestReaderFormat < MiniTest::Unit::TestCase
+  def setup
+    @format = Yamlr::Reader::Format
+    @opt = {}
+    Yamlr::Defaults.options.each_key {|k| @opt[k] = false}
+    @phs    = { :msg => nil,
+                :spc => nil,
+                :key => nil,
+                :val => nil,
+                :ask => nil,
+                :asv => nil,
+                :opt => @opt}
+  end
+
+  #
+  # parsed_hash => formatted_hash
+  #
+  def test_format_basic
+    phs = @phs.merge({:key => "1", :val => "1", :opt => @opt})
+    act = @format.format(phs)
+    assert_equal Hash, act.class
+  end
+
+  def test_adjust_options
+    phs1 = {:opt => {:auto_sym => true}}
+    phs2 = {:opt => {:auto_sym => false}}
+    @format.adjust_options(phs1)
+    @format.adjust_options(phs2)
+    assert phs1[:opt][:auto_sym_keys]
+    assert phs1[:opt][:auto_sym_vals]
+    assert !phs2[:opt][:auto_sym_keys]
+    assert !phs2[:opt][:auto_sym_vals]
+  end
+
+  def test_format_symbolize_keys_number_in_string
+    opt1 = @opt.merge({:symbolize_keys => true})
+    opt2 = @opt.merge({:int => true, :symbolize_keys => true})
+    phs1 = @phs.merge({:key => "1", :val => "1", :opt => opt1})
+    phs2 = @phs.merge({:key => "1", :val => "1", :opt => opt2})
+    act1 = @format.format(phs1)
+    act2 = @format.format(phs2)
+    exp1 = "1".to_sym
+    exp2 = "1".to_sym
+    assert_equal exp1, act1[:key]
+    assert_equal exp2, act2[:key]
+  end
+
+  #def test_format_sym_str_nested
+  #end
+
+  def test_format_sym_str
+    opt1 = @opt.merge({:sym_str => true})
+    opt2 = @opt.merge({:int => true, :sym_str => true})
+    opt3 = opt1
+    phs1 = @phs.merge({:key => "1", :val => "1", :opt => opt1})
+    phs2 = @phs.merge({:key => "1", :val => "1", :opt => opt2})
+    phs3 = @phs.merge({:key => "awesome", :val => "awesome", :opt => opt3})
+    act1 = @format.format(phs1)
+    act2 = @format.format(phs2)
+    act3 = @format.format(phs3)
+    exp1 = :"1"
+    exp2 = 1
+    exp3 = "awesome".to_sym
+    exp4 = :"1"
+    exp5 = 1
+    exp6 = "awesome".to_sym
+    assert_equal exp1, act1[:key]
+    assert_equal exp2, act2[:key]
+    assert_equal exp3, act3[:key]
+    assert_equal exp4, act1[:val]
+    assert_equal exp5, act2[:val]
+    assert_equal exp6, act3[:val]
+  end
+
+  def test_format_sym_str_keys
+    opt1 = @opt.merge({:sym_str_keys => true})
+    opt2 = @opt.merge({:int => true, :sym_str_keys => true})
+    opt3 = opt1
+    phs1 = @phs.merge({:key => "1", :val => "1", :opt => opt1})
+    phs2 = @phs.merge({:key => "1", :val => "1", :opt => opt2})
+    phs3 = @phs.merge({:key => "awesome", :val => "awesome", :opt => opt3})
+    act1 = @format.format(phs1)
+    act2 = @format.format(phs2)
+    act3 = @format.format(phs3)
+    exp1 = :"1"
+    exp2 = 1
+    exp3 = "awesome".to_sym
+    exp4 = "1"
+    exp5 = 1
+    exp6 = "awesome"
+    assert_equal exp1, act1[:key]
+    assert_equal exp2, act2[:key]
+    assert_equal exp3, act3[:key]
+    assert_equal exp4, act1[:val]
+    assert_equal exp5, act2[:val]
+    assert_equal exp6, act3[:val]
+  end
+
+  def test_format_sym_str_vals
+    opt1 = @opt.merge({:sym_str_vals => true})
+    opt2 = @opt.merge({:int => true, :sym_str_vals => true})
+    phs1 = @phs.merge({:key => "1", :val => "1", :opt => opt1})
+    phs2 = @phs.merge({:key => "1", :val => "1", :opt => opt2})
+    phs3 = @phs.merge({:key => "awesome", :val => "awesome", :opt => opt1})
+    act1 = @format.format(phs1)
+    act2 = @format.format(phs2)
+    act3 = @format.format(phs3)
+    assert_equal "1", act1[:key]
+    assert_equal 1, act2[:key]
+    assert_equal "awesome", act3[:key]
+    assert_equal :"1", act1[:val]
+    assert_equal 1, act2[:val]
+    assert_equal "awesome".to_sym, act3[:val]
+  end
+
+  #
+  # strip different things
+  #
+  def test_strip
+    key = "    awesome   "
+    val = "    awesome   "
+    opt1 = {:strip => true}
+    opt2 = @opt.clone
+    act_phs1 = @phs.merge({:key => key, :val => val, :opt => opt1})
+    act_phs2 = @phs.merge({:key => key, :val => val, :opt => opt2})
+    exp_key1 = "awesome"
+    exp_val1 = "awesome"
+    exp_key2 = key
+    exp_val2 = val
+    @format.format(act_phs1)
+    @format.format(act_phs2)
+    assert_equal exp_key1, act_phs1[:key]
+    assert_equal exp_val1, act_phs1[:val]
+    assert_equal exp_key2, act_phs2[:key]
+    assert_equal exp_val2, act_phs2[:val]
+  end
+
+  def test_strip_keys
+    key = "    awesome   "
+    opt1 = {:strip_keys => true}
+    opt2 = @opt.clone
+    act_phs1 = @phs.merge({:key => key, :opt => opt1})
+    act_phs2 = @phs.merge({:key => key, :opt => opt2})
+    exp_key1 = "awesome"
+    exp_key2 = key
+    @format.format(act_phs1)
+    @format.format(act_phs2)
+    assert_equal exp_key1, act_phs1[:key]
+    assert_equal exp_key2, act_phs2[:key]
+  end
+
+  def test_strip_vals
+    val = "    awesome   "
+    opt1 = {:strip_vals => true}
+    opt2 = @opt.clone
+    act_phs1 = @phs.merge({:val => val, :opt => opt1})
+    act_phs2 = @phs.merge({:val => val, :opt => opt2})
+    exp_val1 = "awesome"
+    exp_val2 = val
+    @format.format(act_phs1)
+    @format.format(act_phs2)
+    assert_equal exp_val1, act_phs1[:val]
+    assert_equal exp_val2, act_phs2[:val]
+  end
+
+  #
+  # convert true, false in strings
+  #
+  def test_true_keys
+    opt1 = @opt.clone
+    opt2 = @opt.merge({:auto_true_keys => true})
+    opt3 = @opt.merge({:auto_true => true})
+    opt4 = @opt.clone
+    opt5 = @opt.merge({:auto_true_keys => true})
+    opt6 = @opt.merge({:auto_true => true})
+    act_phs1 = @phs.merge({:key => "true", :opt => opt1})
+    act_phs2 = @phs.merge({:key => "true", :opt => opt2})
+    act_phs3 = @phs.merge({:key => "true", :opt => opt3})
+    act_phs4 = @phs.merge({:key => "false", :opt => opt4})
+    act_phs5 = @phs.merge({:key => "false", :opt => opt5})
+    act_phs6 = @phs.merge({:key => "false", :opt => opt6})
+    @format.key_to_true(act_phs1)
+    @format.key_to_true(act_phs2)
+    @format.key_to_true(act_phs3)
+    @format.key_to_true(act_phs4)
+    @format.key_to_true(act_phs5)
+    @format.key_to_true(act_phs6)
+    assert_equal "true", act_phs1[:key]
+    assert_equal true, act_phs2[:key]
+    assert_equal true, act_phs3[:key]
+    assert_equal "false", act_phs4[:key]
+    assert_equal false, act_phs5[:key]
+    assert_equal false, act_phs6[:key]
+  end
+
+  def test_true_vals
+    opt1 = @opt.clone
+    opt2 = @opt.merge({:auto_true_vals => true})
+    opt3 = @opt.merge({:auto_true => true})
+    opt4 = @opt.clone
+    opt5 = @opt.merge({:auto_true_vals => true})
+    opt6 = @opt.merge({:auto_true => true})
+    act_phs1 = @phs.merge({:val => "true", :opt => opt1})
+    act_phs2 = @phs.merge({:val => "true", :opt => opt2})
+    act_phs3 = @phs.merge({:val => "true", :opt => opt3})
+    act_phs4 = @phs.merge({:val => "false", :opt => opt4})
+    act_phs5 = @phs.merge({:val => "false", :opt => opt5})
+    act_phs6 = @phs.merge({:val => "false", :opt => opt6})
+    @format.val_to_true(act_phs1)
+    @format.val_to_true(act_phs2)
+    @format.val_to_true(act_phs3)
+    @format.val_to_true(act_phs4)
+    @format.val_to_true(act_phs5)
+    @format.val_to_true(act_phs6)
+    assert_equal "true", act_phs1[:val]
+    assert_equal true, act_phs2[:val]
+    assert_equal true, act_phs3[:val]
+    assert_equal "false", act_phs4[:val]
+    assert_equal false, act_phs5[:val]
+    assert_equal false, act_phs6[:val]
+  end
+
+  #
+  # symbolize key
+  #
+  def test_key_to_sym
+    exp_key1 = "awesome"
+    exp_key2 = "awesome".to_sym
+    opt1 = @opt.clone
+    opt2 = @opt.merge({:auto_sym_keys => true})
+    opt3 = @opt.merge({:symbolize => true})
+    opt4 = @opt.merge({:symbolize_keys => true})
+    act_phs1 = @phs.merge({:key => "awesome", :opt => opt1})
+    act_phs2 = @phs.merge({:key => "awesome", :opt => opt2})
+    act_phs3 = @phs.merge({:key => "awesome", :opt => opt3})
+    act_phs4 = @phs.merge({:key => "awesome", :opt => opt4})
+    @format.key_to_sym(act_phs1)
+    @format.key_to_sym(act_phs2)
+    @format.key_to_sym(act_phs3)
+    @format.key_to_sym(act_phs4)
+    assert_equal exp_key1, act_phs1[:key]
+    assert_equal exp_key1, act_phs2[:key]
+    assert_equal exp_key2, act_phs3[:key]
+    assert_equal exp_key2, act_phs4[:key]
+  end
+
+  def test_key_to_sym_number_in_string
+    exp_key1 = "411"
+    exp_key2 = "411".to_sym
+    opt1 = @opt.clone
+    opt2 = @opt.merge({:auto_sym_keys => true})
+    opt3 = @opt.merge({:symbolize => true})
+    opt4 = @opt.merge({:symbolize_keys => true})
+    act_phs1 = @phs.merge({:key => "411", :opt => opt1})
+    act_phs2 = @phs.merge({:key => "411", :opt => opt2})
+    act_phs3 = @phs.merge({:key => "411", :opt => opt3})
+    act_phs4 = @phs.merge({:key => "411", :opt => opt4})
+    @format.key_to_sym(act_phs1)
+    @format.key_to_sym(act_phs2)
+    @format.key_to_sym(act_phs3)
+    @format.key_to_sym(act_phs4)
+    assert_equal exp_key1, act_phs1[:key]
+    assert_equal exp_key1, act_phs2[:key]
+    assert_equal exp_key2, act_phs3[:key]
+    assert_equal exp_key2, act_phs4[:key]
+  end
+
+  #
+  # symbolize val
+  #
+  def test_val_to_sym
+    exp_val1 = "awesome"
+    exp_val2 = "awesome".to_sym
+    opt1 = @opt.clone
+    opt2 = @opt.merge({:auto_sym_vals => true})
+    opt3 = @opt.merge({:symbolize => true})
+    opt4 = @opt.merge({:symbolize_vals => true})
+    act_phs1 = @phs.merge({:val => "awesome", :opt => opt1})
+    act_phs2 = @phs.merge({:val => "awesome", :opt => opt2})
+    act_phs3 = @phs.merge({:val => "awesome", :opt => opt3})
+    act_phs4 = @phs.merge({:val => "awesome", :opt => opt4})
+    @format.val_to_sym(act_phs1)
+    @format.val_to_sym(act_phs2)
+    @format.val_to_sym(act_phs3)
+    @format.val_to_sym(act_phs4)
+    assert_equal exp_val1, act_phs1[:val]
+    assert_equal exp_val1, act_phs2[:val]
+    assert_equal exp_val2, act_phs3[:val]
+    assert_equal exp_val2, act_phs4[:val]
+  end
+
+  def test_val_to_sym_number_in_string
+    exp_val1 = "411"
+    exp_val2 = "411".to_sym
+    opt1 = @opt.clone
+    opt2 = @opt.merge({:auto_sym_vals => true})
+    opt3 = @opt.merge({:symbolize => true})
+    opt4 = @opt.merge({:symbolize_vals => true})
+    act_phs1 = @phs.merge({:val => "411", :opt => opt1})
+    act_phs2 = @phs.merge({:val => "411", :opt => opt2})
+    act_phs3 = @phs.merge({:val => "411", :opt => opt3})
+    act_phs4 = @phs.merge({:val => "411", :opt => opt4})
+    @format.val_to_sym(act_phs1)
+    @format.val_to_sym(act_phs2)
+    @format.val_to_sym(act_phs3)
+    @format.val_to_sym(act_phs4)
+    assert_equal exp_val1, act_phs1[:val]
+    assert_equal exp_val1, act_phs2[:val]
+    assert_equal exp_val2, act_phs3[:val]
+    assert_equal exp_val2, act_phs4[:val]
+  end
+
+  # key is parsed as string, try to_i
+  #
+  def test_key_to_int_string
+    opt1 = @opt.clone
+    opt2 = @opt.merge({:int => true})
+    opt3 = @opt.merge({:int_keys => true})
+    opt4 = @opt.merge({:int => true})
+    opt5 = @opt.merge({:int_keys => true})
+    act_phs1 = @phs.merge({:key => "411", :opt => opt1})
+    act_phs2 = @phs.merge({:key => "411", :opt => opt2})
+    act_phs3 = @phs.merge({:key => "411", :opt => opt3})
+    act_phs4 = @phs.merge({:key => "411".to_sym, :opt => opt4})
+    act_phs5 = @phs.merge({:key => "411".to_sym, :opt => opt5})
+    @format.key_to_int(act_phs1)
+    @format.key_to_int(act_phs2)
+    @format.key_to_int(act_phs3)
+    @format.key_to_int(act_phs4)
+    @format.key_to_int(act_phs5)
+    assert_equal "411", act_phs1[:key]
+    assert_equal 411, act_phs2[:key]
+    assert_equal 411, act_phs3[:key]
+    assert_equal 411, act_phs4[:key]
+    assert_equal 411, act_phs5[:key]
+  end
+
+  # val is parsed as string, try to_i
+  #
+  def test_val_to_int
+    opt1 = @opt.clone
+    opt2 = @opt.merge({:int => true})
+    opt3 = @opt.merge({:int_vals => true})
+    opt4 = @opt.merge({:int => true})
+    opt5 = @opt.merge({:int_vals => true})
+    act_phs1 = @phs.merge({:val => "411", :opt => opt1})
+    act_phs2 = @phs.merge({:val => "411", :opt => opt2})
+    act_phs3 = @phs.merge({:val => "411", :opt => opt3})
+    act_phs4 = @phs.merge({:val => "411".to_sym, :opt => opt4})
+    act_phs5 = @phs.merge({:val => "411".to_sym, :opt => opt5})
+    @format.val_to_int(act_phs1)
+    @format.val_to_int(act_phs2)
+    @format.val_to_int(act_phs3)
+    @format.val_to_int(act_phs4)
+    @format.val_to_int(act_phs5)
+    assert_equal "411", act_phs1[:val]
+    assert_equal 411, act_phs2[:val]
+    assert_equal 411, act_phs3[:val]
+    assert_equal 411, act_phs4[:val]
+    assert_equal 411, act_phs5[:val]
+  end
+
+  #
+  # returns Int if String is convertable
+  #
+  def test_string_to_int
+    str1 = ""
+    str2 = "awesome"
+    str3 = "123awesome"
+    str4 = "123"
+    exp1 = ""
+    exp2 = "awesome"
+    exp3 = "123awesome"
+    exp4 = 123
+    act1 = @format.string_to_int(str1)
+    act2 = @format.string_to_int(str2)
+    act3 = @format.string_to_int(str3)
+    act4 = @format.string_to_int(str4)
+    assert_equal exp1, act1
+    assert_equal exp2, act2
+    assert_equal exp3, act3
+    assert_equal exp4, act4
+  end
+end

data/test/test_reader_parser.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby -w
+
+require 'rubygems'
+require 'minitest/unit'
+$: << 'lib' << 'test'
+require 'yamlr/reader/node'
+require 'yamlr/reader/parser'
+require 'yamlr/indicators'
+MiniTest::Unit.autorun
+
+class TestReaderParser < MiniTest::Unit::TestCase
+  def setup
+    @parser = Yamlr::Reader::Parser
+    @opt    = Yamlr::Indicators.options
+  end
+
+  def test_parser_module
+    assert_kind_of Module, @parser
+  end
+
+  def test_parse_raise_indenterror
+    lin1 = " 7:7"
+    spc1 = 1
+    idt1 = 2
+    num1 = 88
+    assert_raises(Yamlr::Reader::Parser::IndentError) {
+      @parser.check_indent(lin1, spc1, idt1, num1)
+    }
+  end
+
+  def test_check_indent_no_raise_indenterror
+    lin1 = "  7:7"
+    spc1 = 2
+    idt1 = 2
+    num1 = 88
+    assert_nil @parser.check_indent(lin1, spc1, idt1, num1)
+  end
+
+  def test_parse_comment
+    line = "#dude"
+    phs = @parser.parse(line, @opt, 77)
+    exp_msg = "com".to_sym
+    exp_spc = 0
+    exp_key = ""
+    exp_val = "dude"
+    exp_ask = nil
+    exp_asv = nil
+    exp_opt = @opt
+    assert_equal exp_msg, phs[:msg]
+    assert_equal exp_spc, phs[:spc]
+    assert_equal exp_key, phs[:key]
+    assert_equal exp_val, phs[:val]
+    assert_equal exp_ask, phs[:ask]
+    assert_equal exp_asv, phs[:asv]
+    assert_equal exp_opt, phs[:opt]
+  end
+
+  # parsed line => [msg, spc, key, val, ask, asv, opt]
+  def test_results_to_hash
+    results = [1, "  ", "3", "4", 5, 6]
+    phs     = @parser.results_to_hash(results, 7)
+    exp_msg = 1
+    exp_spc = 2
+    exp_key = "3"
+    exp_val = "4"
+    exp_ask = 5
+    exp_asv = 6
+    exp_opt = 7
+    assert_equal exp_msg, phs[:msg]
+    assert_equal exp_spc, phs[:spc]
+    assert_equal exp_key, phs[:key]
+    assert_equal exp_val, phs[:val]
+    assert_equal exp_ask, phs[:ask]
+    assert_equal exp_asv, phs[:asv]
+    assert_equal exp_opt, phs[:opt]
+  end
+
+  def test_parse_line_malformed
+    line = "awesome"
+    phs = @parser.parse_line(line, @opt)
+    assert_equal :mal, phs[0]
+    assert_equal "awesome", phs[3]
+  end
+
+  def test_parse_line_blank
+    line1 = "  "
+    line2 = ""
+    exp_phs1 = @parser.parse_line(line1, @opt)
+    exp_phs2 = @parser.parse_line(line2, @opt)
+    assert_equal :bla, exp_phs1[0]
+    assert_equal :bla, exp_phs2[0]
+  end
+
+  def test_parse_line_comment
+    line1 = "  #awesome"
+    line2 = "# dude"
+    line3 = "###beer"
+    line4 = "    #   camaro"
+    exp_phs1 = @parser.parse_line(line1, @opt)
+    exp_phs2 = @parser.parse_line(line2, @opt)
+    exp_phs3 = @parser.parse_line(line3, @opt)
+    exp_phs4 = @parser.parse_line(line4, @opt)
+    assert_equal :com, exp_phs1[0]
+    assert_equal :com, exp_phs2[0]
+    assert_equal :com, exp_phs3[0]
+    assert_equal :com, exp_phs4[0]
+    assert_equal "awesome", exp_phs1.flatten[3]
+    assert_equal "dude",    exp_phs2.flatten[3]
+    assert_equal "##beer",  exp_phs3.flatten[3]
+    assert_equal "camaro",  exp_phs4.flatten[3]
+  end
+
+  def test_parse_line_array
+    line1 = "- awesome"
+    line2 = "  -dude"
+    line3 = "     -- beer"
+    line4 = "    -     #camaro"
+    exp_phs1 = @parser.parse_line(line1, @opt)
+    exp_phs2 = @parser.parse_line(line2, @opt)
+    exp_phs3 = @parser.parse_line(line3, @opt)
+    exp_phs4 = @parser.parse_line(line4, @opt)
+    assert_equal :arr, exp_phs1[0]
+    assert_equal :arr, exp_phs2[0]
+    assert_equal :arr, exp_phs3[0]
+    assert_equal :arr, exp_phs4[0]
+    assert_equal "",        exp_phs1.flatten[1]
+    assert_equal "  ",      exp_phs2.flatten[1]
+    assert_equal "     ",   exp_phs3.flatten[1]
+    assert_equal "    ",    exp_phs4.flatten[1]
+    assert_equal "awesome", exp_phs1.flatten[3]
+    assert_equal "dude",    exp_phs2.flatten[3]
+    assert_equal "- beer",  exp_phs3.flatten[3]
+    assert_equal "#camaro", exp_phs4.flatten[3]
+  end
+
+  def test_parse_line_hashkey
+    line1 = "awesome:"
+    line2 = "  dude :"
+    line3 = "     :beer:"
+    line4 = '    "camaro":'
+    exp_phs1 = @parser.parse_line(line1, @opt)
+    exp_phs2 = @parser.parse_line(line2, @opt)
+    exp_phs3 = @parser.parse_line(line3, @opt)
+    exp_phs4 = @parser.parse_line(line4, @opt)
+    assert_equal :hky, exp_phs1[0]
+    assert_equal :mal, exp_phs2[0]
+    assert_equal :hky, exp_phs3[0]
+    assert_equal :hky, exp_phs4[0]
+    assert_equal "",        exp_phs1.flatten[1]
+    assert_equal "     ",   exp_phs3.flatten[1]
+    assert_equal "    ",    exp_phs4.flatten[1]
+    assert_equal "awesome",   exp_phs1.flatten[2]
+    assert_equal ":beer",      exp_phs3.flatten[2]
+    assert_equal '"camaro"',  exp_phs4.flatten[2]
+    assert_equal nil,   exp_phs1.flatten[4]
+    assert_equal true,  exp_phs3.flatten[4]
+    assert_equal nil,   exp_phs4.flatten[4]
+  end
+
+  def test_parse_line_hashpair
+    line1 = "awesome:dude"
+    line2 = "  :dude::fekja"
+    line3 = "     :beer:coke"
+    line4 = '    "camaro"::firebird'
+    exp_phs1 = @parser.parse_line(line1, @opt)
+    exp_phs2 = @parser.parse_line(line2, @opt)
+    exp_phs3 = @parser.parse_line(line3, @opt)
+    exp_phs4 = @parser.parse_line(line4, @opt)
+    assert_equal :hpr, exp_phs1[0]
+    assert_equal :hpr, exp_phs2[0]
+    assert_equal :hpr, exp_phs3[0]
+    assert_equal :hpr, exp_phs4[0]
+    assert_equal "",        exp_phs1.flatten[1]
+    assert_equal "  ",      exp_phs2.flatten[1]
+    assert_equal "     ",   exp_phs3.flatten[1]
+    assert_equal "    ",    exp_phs4.flatten[1]
+    assert_equal "awesome",   exp_phs1.flatten[2]
+    assert_equal ":dude",     exp_phs2.flatten[2]
+    assert_equal ":beer",     exp_phs3.flatten[2]
+    assert_equal '"camaro"',  exp_phs4.flatten[2]
+    assert_equal nil,   exp_phs1.flatten[4]
+    assert_equal true,  exp_phs2.flatten[4]
+    assert_equal true,  exp_phs3.flatten[4]
+    assert_equal nil,   exp_phs4.flatten[4]
+    assert_equal nil,   exp_phs1.flatten[5]
+    assert_equal true,  exp_phs2.flatten[5]
+    assert_equal nil,   exp_phs3.flatten[5]
+    assert_equal true,  exp_phs4.flatten[5]
+  end
+end