← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ruby1.9/intrepid-updates

« back to all changes in this revision

Viewing changes to test/ruby/test_assignment.rb

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-09-04 16:01:17 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20070904160117-i15zckg2nhxe9fyw
Tags: 1.9.0+20070830-2ubuntu1
* Sync from Debian; remaining changes:
  - Add -g to CFLAGS.
* Fixes build failure on ia64.
* Fixes build failure with gcc-4.2 on lpia.
* Robustify check for target_os, fixing build failure on lpia.
* Set Ubuntu maintainer address.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/ruby/test_assignment.rb
90
90
    def f; yield([*[1]]); end; f {|a| assert_equal([1], a)}; undef f
91
91
    def f; yield([*[1,2]]); end; f {|a| assert_equal([1,2], a)}; undef f
92
92
 
93
 
    def f; yield(*[1]); end; f {|a| assert_equal([1], a)}; undef f
94
 
    def f; yield(*[nil]); end; f {|a| assert_equal([nil], a)}; undef f
95
 
    def f; yield(*[[]]); end; f {|a| assert_equal([[]], a)}; undef f
96
 
    def f; yield(*[*[1]]); end; f {|a| assert_equal([1], a)}; undef f
 
93
    def f; yield(*[1]); end; f {|a| assert_equal(1, a)}; undef f
 
94
    def f; yield(*[nil]); end; f {|a| assert_equal(nil, a)}; undef f
 
95
    def f; yield(*[[]]); end; f {|a| assert_equal([], a)}; undef f
 
96
    def f; yield(*[*[1]]); end; f {|a| assert_equal(1, a)}; undef f
97
97
 
98
98
    def f; yield; end; f {|*a| assert_equal([], a)}; undef f
99
99
    def f; yield(nil); end; f {|*a| assert_equal([nil], a)}; undef f
100
100
    def f; yield(1); end; f {|*a| assert_equal([1], a)}; undef f
101
 
    def f; yield([]); end; f {|*a| assert_equal([], a)}; undef f
102
 
    def f; yield([1]); end; f {|*a| assert_equal([1], a)}; undef f
103
 
    def f; yield([nil]); end; f {|*a| assert_equal([nil], a)}; undef f
104
 
    def f; yield([[]]); end; f {|*a| assert_equal([[]], a)}; undef f
105
 
    def f; yield([1,2]); end; f {|*a| assert_equal([1,2], a)}; undef f
106
 
    def f; yield([*[]]); end; f {|*a| assert_equal([], a)}; undef f
107
 
    def f; yield([*[1]]); end; f {|*a| assert_equal([1], a)}; undef f
108
 
    def f; yield([*[1,2]]); end; f {|*a| assert_equal([1,2], a)}; undef f
 
101
    def f; yield([]); end; f {|*a| assert_equal([[]], a)}; undef f
 
102
    def f; yield([1]); end; f {|*a| assert_equal([[1]], a)}; undef f
 
103
    def f; yield([nil]); end; f {|*a| assert_equal([[nil]], a)}; undef f
 
104
    def f; yield([[]]); end; f {|*a| assert_equal([[[]]], a)}; undef f
 
105
    def f; yield([1,2]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
 
106
    def f; yield([*[]]); end; f {|*a| assert_equal([[]], a)}; undef f
 
107
    def f; yield([*[1]]); end; f {|*a| assert_equal([[1]], a)}; undef f
 
108
    def f; yield([*[1,2]]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
109
109
 
110
110
    def f; yield(*[]); end; f {|*a| assert_equal([], a)}; undef f
111
111
    def f; yield(*[1]); end; f {|*a| assert_equal([1], a)}; undef f
129
129
    def f; yield(*[]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
130
130
    def f; yield(*[1]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
131
131
    def f; yield(*[nil]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
132
 
    def f; yield(*[[]]); end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}; undef f
 
132
    def f; yield(*[[]]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
133
133
    def f; yield(*[*[]]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
134
134
    def f; yield(*[*[1]]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
135
135
    def f; yield(*[*[1,2]]); end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}; undef f
489
489
    assert_equal [3,4], [a,b]
490
490
  end
491
491
end
 
492
 
 
493
require 'sentence'
 
494
class TestAssignmentGen < Test::Unit::TestCase
 
495
  Syntax = {
 
496
    :exp => [["0"],
 
497
             ["nil"],
 
498
             ["false"],
 
499
             ["[]"],
 
500
             ["[",:exps,"]"]],
 
501
    :exps => [[:exp],
 
502
              [:exp,",",:exps]],
 
503
    :arg => [[:exp]],
 
504
    :mrhs => [[:args,",",:arg],
 
505
              [:args,",","*",:arg],
 
506
              ["*",:arg]],
 
507
    :args => [[:arg],
 
508
              ["*",:arg],
 
509
              [:args,",",:arg],
 
510
              [:args,",","*",:arg]],
 
511
    :mlhs => [[:mlhs_basic],
 
512
              ["(",:mlhs_inner,")"]],
 
513
    :mlhs_inner => [[:mlhs_basic],
 
514
              ["(",:mlhs_inner,")"]],
 
515
    :mlhs_basic => [[:mlhs_head],
 
516
                    [:mlhs_head,:mlhs_item],
 
517
                    [:mlhs_head,"*",:mlhs_node],
 
518
                    [:mlhs_head,"*",:mlhs_node,",",:mlhs_post],
 
519
                    [:mlhs_head,"*"],
 
520
                    [:mlhs_head,"*",",",           :mlhs_post],
 
521
                    [           "*",:mlhs_node],
 
522
                    [           "*",:mlhs_node,",",:mlhs_post],
 
523
                    [           "*"],
 
524
                    [           "*",",",           :mlhs_post]],
 
525
    :mlhs_head => [[:mlhs_item,","],
 
526
                   [:mlhs_head,:mlhs_item,","]],
 
527
    :mlhs_post => [[:mlhs_item],
 
528
                   [:mlhs_post,",",:mlhs_item]],
 
529
    :mlhs_item => [[:mlhs_node],
 
530
                   ["(",:mlhs_inner,")"]],
 
531
    :mlhs_node => [["var"]],
 
532
    :xassign => [["var"," = ",:exp],
 
533
                 ["var"," = ",:mrhs],
 
534
                 [:mlhs," = ",:exp],
 
535
                 [:mlhs," = ",:mrhs]],
 
536
  }
 
537
 
 
538
  def rename_var(obj)
 
539
    vars = []
 
540
    r = obj.subst('var') {
 
541
      var = "v#{vars.length}"
 
542
      vars << var
 
543
      var
 
544
    }
 
545
    return r, vars
 
546
  end
 
547
 
 
548
  def expand_except_paren(obj)
 
549
    return obj if obj.respond_to? :to_str
 
550
    obj.expand {|s|
 
551
      !(s[0] == '(' && s[-1] == ')') &&
 
552
      !(s[0] == '[' && s[-1] == ']')
 
553
    }
 
554
  end
 
555
 
 
556
  def extract_single_element(ary)
 
557
    raise "not a single element array: #{ary.inspect}" if ary.length != 1
 
558
    ary[0]
 
559
  end
 
560
 
 
561
  def emu_assign_ary(lhs, rv, h)
 
562
    rv = rv.respond_to?(:to_ary) ? rv : [rv]
 
563
    rv = rv.dup
 
564
    a = [[]]
 
565
    lhs.each {|e|
 
566
      if e == ','
 
567
        a << []
 
568
      else
 
569
        a.last << e
 
570
      end
 
571
    }
 
572
    a.pop if a.last == []
 
573
    pre = []
 
574
    star = post = nil
 
575
    a.each {|e|
 
576
      if post
 
577
        post << e
 
578
      elsif e[0] == '*'
 
579
        star = e
 
580
        post = []
 
581
      else
 
582
        pre << e
 
583
      end
 
584
    }
 
585
    pre.map! {|e| extract_single_element(e) }
 
586
    if star
 
587
      if star == ['*']
 
588
        star = nil
 
589
      else
 
590
        star = extract_single_element(star[1..-1])
 
591
      end
 
592
    end
 
593
    post.map! {|e| extract_single_element(e) } if post
 
594
 
 
595
    until pre.empty?
 
596
      emu_assign_single(pre.shift, rv.shift, h)
 
597
    end
 
598
 
 
599
    if post
 
600
      if rv.length < post.length
 
601
        until post.empty?
 
602
          emu_assign_single(post.shift, rv.shift, h)
 
603
        end
 
604
      else
 
605
        until post.empty?
 
606
          emu_assign_single(post.pop, rv.pop, h)
 
607
        end
 
608
      end
 
609
    end
 
610
 
 
611
    if star
 
612
      emu_assign_single(star, rv, h)
 
613
    end
 
614
  end
 
615
 
 
616
  def emu_assign_single(lhs, rv, h={})
 
617
    if lhs.respond_to? :to_str
 
618
      if /\A[a-z0-9]+\z/ =~ lhs
 
619
        h[lhs] = rv
 
620
      else
 
621
        raise "unexpected lhs string: #{lhs.inspect}"
 
622
      end
 
623
    elsif Sentence === lhs
 
624
      if lhs[0] == '(' && lhs[-1] == ')'
 
625
        emu_assign_ary(lhs[1...-1], rv, h)
 
626
      elsif lhs.length == 1 && String === lhs[0] && /\A[a-z0-9]+\z/ =~ lhs[0]
 
627
        h[lhs[0]] = rv
 
628
      else
 
629
        raise "unexpected lhs sentence: #{lhs.inspect}"
 
630
      end
 
631
    else
 
632
      raise "unexpected lhs: #{lhs.inspect}"
 
633
    end
 
634
    h
 
635
  end
 
636
 
 
637
  def emu_assign(assign)
 
638
    lhs = expand_except_paren(assign[0])
 
639
    rhs = expand_except_paren(assign[2])
 
640
    lopen = Sentence === lhs && lhs[-1] != ')' && lhs.any? {|e| e == '*' || e == ',' }
 
641
    ropen = Sentence === rhs && rhs[-1] != ']' && rhs.any? {|e| e == '*' || e == ',' }
 
642
    lhs = Sentence.new(['(']+lhs.to_a+[')']) if lopen
 
643
    begin
 
644
      rv = eval((ropen ? ["[",assign[2],"]"] : assign[2]).join(''))
 
645
    rescue Exception
 
646
      rv = $!.message
 
647
    end
 
648
    emu_assign_single(lhs, rv)
 
649
  end
 
650
 
 
651
  def do_assign(assign, vars)
 
652
    assign = assign.to_s
 
653
    code1 = "#{assign}; [#{vars.join(",")}]"
 
654
    assign.gsub!(/\bv\d+\b/, "o.a")
 
655
    code2 = "o=[];class << o; self end.send!(:define_method,:a=){|v|self << v};#{assign};o"
 
656
    begin
 
657
      vals1 = eval(code1)
 
658
    rescue Exception
 
659
      return {:ex=>$!.message}
 
660
    end
 
661
    begin
 
662
      vals2 = eval(code2)
 
663
    rescue Exception
 
664
      return {:ex=>$!.message}
 
665
    end
 
666
    assert_equal(vals1, vals2, code1)
 
667
    vals = vals1
 
668
    h = {}
 
669
    [vars, vals].transpose.each {|k,v| h[k] = v }
 
670
    h
 
671
  end
 
672
 
 
673
  def check(assign)
 
674
    assign, vars = rename_var(assign)
 
675
    sent = assign.to_s
 
676
    bruby = do_assign(assign, vars).to_a.sort
 
677
    bemu = emu_assign(assign).to_a.sort
 
678
    assert_equal(bemu, bruby, sent)
 
679
  end
 
680
 
 
681
  def test_assignment
 
682
    syntax = Sentence.expand_syntax(Syntax)
 
683
    Sentence.each(syntax, :xassign, 4) {|assign|
 
684
      check(assign)
 
685
    }
 
686
  end
 
687
end