aboutsummaryrefslogtreecommitdiffstats
path: root/test/ruby
diff options
context:
space:
mode:
Diffstat (limited to 'test/ruby')
-rw-r--r--test/ruby/test_assignment.rb176
-rw-r--r--test/ruby/test_clone.rb2
-rw-r--r--test/ruby/test_dir.rb6
-rw-r--r--test/ruby/test_file.rb2
-rw-r--r--test/ruby/test_float.rb28
-rw-r--r--test/ruby/test_iterator.rb30
-rw-r--r--test/ruby/test_stringchar.rb8
7 files changed, 140 insertions, 112 deletions
diff --git a/test/ruby/test_assignment.rb b/test/ruby/test_assignment.rb
index 5a0e06478f..0e11d6bad6 100644
--- a/test/ruby/test_assignment.rb
+++ b/test/ruby/test_assignment.rb
@@ -29,25 +29,25 @@ class TestAssignment < Test::Unit::TestCase
a = [*[1]]; assert_equal([1], a)
a = [*[1,2]]; assert_equal([1,2], a)
- a = *[]; assert_nil(a)
- a = *[1]; assert_equal(1, a)
- a = *[nil]; assert_nil(a)
- a = *[[]]; assert_equal([], a)
+ a = *[]; assert_equal([], a)
+ a = *[1]; assert_equal([1], a)
+ a = *[nil]; assert_equal([nil], a)
+ a = *[[]]; assert_equal([[]], a)
a = *[1,2]; assert_equal([1,2], a)
- a = *[*[]]; assert_nil(a)
- a = *[*[1]]; assert_equal(1, a)
+ a = *[*[]]; assert_equal([], a)
+ a = *[*[1]]; assert_equal([1], a)
a = *[*[1,2]]; assert_equal([1,2], a)
*a = nil; assert_equal([nil], a)
*a = 1; assert_equal([1], a)
- *a = []; assert_equal([[]], a)
- *a = [1]; assert_equal([[1]], a)
- *a = [nil]; assert_equal([[nil]], a)
- *a = [[]]; assert_equal([[[]]], a)
- *a = [1,2]; assert_equal([[1,2]], a)
- *a = [*[]]; assert_equal([[]], a)
- *a = [*[1]]; assert_equal([[1]], a)
- *a = [*[1,2]]; assert_equal([[1,2]], a)
+ *a = []; assert_equal([], a)
+ *a = [1]; assert_equal([1], a)
+ *a = [nil]; assert_equal([nil], a)
+ *a = [[]]; assert_equal([[]], a)
+ *a = [1,2]; assert_equal([1,2], a)
+ *a = [*[]]; assert_equal([], a)
+ *a = [*[1]]; assert_equal([1], a)
+ *a = [*[1,2]]; assert_equal([1,2], a)
*a = *[]; assert_equal([], a)
*a = *[1]; assert_equal([1], a)
@@ -82,13 +82,13 @@ class TestAssignment < Test::Unit::TestCase
def test_yield
def f; yield(nil); end; f {|a| assert_nil(a)}; undef f
def f; yield(1); end; f {|a| assert_equal(1, a)}; undef f
- def f; yield([]); end; f {|a| assert_equal([], a)}; undef f
- def f; yield([1]); end; f {|a| assert_equal([1], a)}; undef f
- def f; yield([nil]); end; f {|a| assert_equal([nil], a)}; undef f
- def f; yield([[]]); end; f {|a| assert_equal([[]], a)}; undef f
- def f; yield([*[]]); end; f {|a| assert_equal([], a)}; undef f
- def f; yield([*[1]]); end; f {|a| assert_equal([1], a)}; undef f
- def f; yield([*[1,2]]); end; f {|a| assert_equal([1,2], a)}; undef f
+ def f; yield([]); end; f {|a| assert_equal(nil, a)}; undef f
+ def f; yield([1]); end; f {|a| assert_equal(1, a)}; undef f
+ def f; yield([nil]); end; f {|a| assert_equal(nil, a)}; undef f
+ def f; yield([[]]); end; f {|a| assert_equal([], a)}; undef f
+ def f; yield([*[]]); end; f {|a| assert_equal(nil, a)}; undef f
+ def f; yield([*[1]]); end; f {|a| assert_equal(1, a)}; undef f
+ def f; yield([*[1,2]]); end; f {|a| assert_equal(1, a)}; undef f
def f; yield(*[1]); end; f {|a| assert_equal(1, a)}; undef f
def f; yield(*[nil]); end; f {|a| assert_nil(a)}; undef f
@@ -98,14 +98,14 @@ class TestAssignment < Test::Unit::TestCase
def f; yield; end; f {|*a| assert_equal([], a)}; undef f
def f; yield(nil); end; f {|*a| assert_equal([nil], a)}; undef f
def f; yield(1); end; f {|*a| assert_equal([1], a)}; undef f
- def f; yield([]); end; f {|*a| assert_equal([[]], a)}; undef f
- def f; yield([1]); end; f {|*a| assert_equal([[1]], a)}; undef f
- def f; yield([nil]); end; f {|*a| assert_equal([[nil]], a)}; undef f
- def f; yield([[]]); end; f {|*a| assert_equal([[[]]], a)}; undef f
- def f; yield([1,2]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
- def f; yield([*[]]); end; f {|*a| assert_equal([[]], a)}; undef f
- def f; yield([*[1]]); end; f {|*a| assert_equal([[1]], a)}; undef f
- def f; yield([*[1,2]]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
+ def f; yield([]); end; f {|*a| assert_equal([], a)}; undef f
+ def f; yield([1]); end; f {|*a| assert_equal([1], a)}; undef f
+ def f; yield([nil]); end; f {|*a| assert_equal([nil], a)}; undef f
+ def f; yield([[]]); end; f {|*a| assert_equal([[]], a)}; undef f
+ def f; yield([1,2]); end; f {|*a| assert_equal([1,2], a)}; undef f
+ def f; yield([*[]]); end; f {|*a| assert_equal([], a)}; undef f
+ def f; yield([*[1]]); end; f {|*a| assert_equal([1], a)}; undef f
+ def f; yield([*[1,2]]); end; f {|*a| assert_equal([1,2], a)}; undef f
def f; yield(*[]); end; f {|*a| assert_equal([], a)}; undef f
def f; yield(*[1]); end; f {|*a| assert_equal([1], a)}; undef f
@@ -147,39 +147,39 @@ class TestAssignment < Test::Unit::TestCase
def r; return [*[1]]; end; a = r(); assert_equal([1], a); undef r
def r; return [*[1,2]]; end; a = r(); assert_equal([1,2], a); undef r
- def r; return *[]; end; a = r(); assert_nil(a); undef r
- def r; return *[1]; end; a = r(); assert_equal(1, a); undef r
- def r; return *[nil]; end; a = r(); assert_nil(a); undef r
- def r; return *[[]]; end; a = r(); assert_equal([], a); undef r
- def r; return *[*[]]; end; a = r(); assert_nil(a); undef r
- def r; return *[*[1]]; end; a = r(); assert_equal(1, a); undef r
+ def r; return *[]; end; a = r(); assert_equal([], a); undef r
+ def r; return *[1]; end; a = r(); assert_equal([1], a); undef r
+ def r; return *[nil]; end; a = r(); assert_equal([nil], a); undef r
+ def r; return *[[]]; end; a = r(); assert_equal([[]], a); undef r
+ def r; return *[*[]]; end; a = r(); assert_equal([], a); undef r
+ def r; return *[*[1]]; end; a = r(); assert_equal([1], a); undef r
def r; return *[*[1,2]]; end; a = r(); assert_equal([1,2], a); undef r
- def r; return *[[]]; end; a = *r(); assert_nil(a); undef r
+ def r; return *[[]]; end; a = *r(); assert_equal([[]], a); undef r
def r; return *[*[1,2]]; end; a = *r(); assert_equal([1,2], a); undef r
def r; return; end; *a = r(); assert_equal([nil], a); undef r
def r; return nil; end; *a = r(); assert_equal([nil], a); undef r
def r; return 1; end; *a = r(); assert_equal([1], a); undef r
- def r; return []; end; *a = r(); assert_equal([[]], a); undef r
- def r; return [1]; end; *a = r(); assert_equal([[1]], a); undef r
- def r; return [nil]; end; *a = r(); assert_equal([[nil]], a); undef r
- def r; return [[]]; end; *a = r(); assert_equal([[[]]], a); undef r
- def r; return [1,2]; end; *a = r(); assert_equal([[1,2]], a); undef r
- def r; return [*[]]; end; *a = r(); assert_equal([[]], a); undef r
- def r; return [*[1]]; end; *a = r(); assert_equal([[1]], a); undef r
- def r; return [*[1,2]]; end; *a = r(); assert_equal([[1,2]], a); undef r
-
- def r; return *[]; end; *a = r(); assert_equal([nil], a); undef r
+ def r; return []; end; *a = r(); assert_equal([], a); undef r
+ def r; return [1]; end; *a = r(); assert_equal([1], a); undef r
+ def r; return [nil]; end; *a = r(); assert_equal([nil], a); undef r
+ def r; return [[]]; end; *a = r(); assert_equal([[]], a); undef r
+ def r; return [1,2]; end; *a = r(); assert_equal([1,2], a); undef r
+ def r; return [*[]]; end; *a = r(); assert_equal([], a); undef r
+ def r; return [*[1]]; end; *a = r(); assert_equal([1], a); undef r
+ def r; return [*[1,2]]; end; *a = r(); assert_equal([1,2], a); undef r
+
+ def r; return *[]; end; *a = r(); assert_equal([], a); undef r
def r; return *[1]; end; *a = r(); assert_equal([1], a); undef r
def r; return *[nil]; end; *a = r(); assert_equal([nil], a); undef r
def r; return *[[]]; end; *a = r(); assert_equal([[]], a); undef r
- def r; return *[1,2]; end; *a = r(); assert_equal([[1,2]], a); undef r
- def r; return *[*[]]; end; *a = r(); assert_equal([nil], a); undef r
+ def r; return *[1,2]; end; *a = r(); assert_equal([1,2], a); undef r
+ def r; return *[*[]]; end; *a = r(); assert_equal([], a); undef r
def r; return *[*[1]]; end; *a = r(); assert_equal([1], a); undef r
- def r; return *[*[1,2]]; end; *a = r(); assert_equal([[1,2]], a); undef r
+ def r; return *[*[1,2]]; end; *a = r(); assert_equal([1,2], a); undef r
- def r; return *[[]]; end; *a = *r(); assert_equal([], a); undef r
+ def r; return *[[]]; end; *a = *r(); assert_equal([[]], a); undef r
def r; return *[1,2]; end; *a = *r(); assert_equal([1,2], a); undef r
def r; return *[*[1,2]]; end; *a = *r(); assert_equal([1,2], a); undef r
@@ -198,7 +198,7 @@ class TestAssignment < Test::Unit::TestCase
def r; return *[]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return *[1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
def r; return *[nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
- def r; return *[[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
+ def r; return *[[]]; end; a,b,*c = r(); assert_equal([[],nil,[]], [a,b,c]); undef r
def r; return *[1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
def r; return *[*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return *[*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
@@ -260,36 +260,36 @@ class TestAssignment < Test::Unit::TestCase
a = loop do break [*[1]]; end; assert_equal([1], a)
a = loop do break [*[1,2]]; end; assert_equal([1,2], a)
- a = loop do break *[]; end; assert_nil(a)
- a = loop do break *[1]; end; assert_equal(1, a)
- a = loop do break *[nil]; end; assert_nil(a)
- a = loop do break *[[]]; end; assert_equal([], a)
- a = loop do break *[*[]]; end; assert_nil(a)
- a = loop do break *[*[1]]; end; assert_equal(1, a)
+ a = loop do break *[]; end; assert_equal([], a)
+ a = loop do break *[1]; end; assert_equal([1], a)
+ a = loop do break *[nil]; end; assert_equal([nil], a)
+ a = loop do break *[[]]; end; assert_equal([[]], a)
+ a = loop do break *[*[]]; end; assert_equal([], a)
+ a = loop do break *[*[1]]; end; assert_equal([1], a)
a = loop do break *[*[1,2]]; end; assert_equal([1,2], a)
*a = loop do break; end; assert_equal([nil], a)
*a = loop do break nil; end; assert_equal([nil], a)
*a = loop do break 1; end; assert_equal([1], a)
- *a = loop do break []; end; assert_equal([[]], a)
- *a = loop do break [1]; end; assert_equal([[1]], a)
- *a = loop do break [nil]; end; assert_equal([[nil]], a)
- *a = loop do break [[]]; end; assert_equal([[[]]], a)
- *a = loop do break [1,2]; end; assert_equal([[1,2]], a)
- *a = loop do break [*[]]; end; assert_equal([[]], a)
- *a = loop do break [*[1]]; end; assert_equal([[1]], a)
- *a = loop do break [*[1,2]]; end; assert_equal([[1,2]], a)
-
- *a = loop do break *[]; end; assert_equal([nil], a)
+ *a = loop do break []; end; assert_equal([], a)
+ *a = loop do break [1]; end; assert_equal([1], a)
+ *a = loop do break [nil]; end; assert_equal([nil], a)
+ *a = loop do break [[]]; end; assert_equal([[]], a)
+ *a = loop do break [1,2]; end; assert_equal([1,2], a)
+ *a = loop do break [*[]]; end; assert_equal([], a)
+ *a = loop do break [*[1]]; end; assert_equal([1], a)
+ *a = loop do break [*[1,2]]; end; assert_equal([1,2], a)
+
+ *a = loop do break *[]; end; assert_equal([], a)
*a = loop do break *[1]; end; assert_equal([1], a)
*a = loop do break *[nil]; end; assert_equal([nil], a)
*a = loop do break *[[]]; end; assert_equal([[]], a)
- *a = loop do break *[1,2]; end; assert_equal([[1,2]], a)
- *a = loop do break *[*[]]; end; assert_equal([nil], a)
+ *a = loop do break *[1,2]; end; assert_equal([1,2], a)
+ *a = loop do break *[*[]]; end; assert_equal([], a)
*a = loop do break *[*[1]]; end; assert_equal([1], a)
- *a = loop do break *[*[1,2]]; end; assert_equal([[1,2]], a)
+ *a = loop do break *[*[1,2]]; end; assert_equal([1,2], a)
- *a = *loop do break *[[]]; end; assert_equal([], a)
+ *a = *loop do break *[[]]; end; assert_equal([[]], a)
*a = *loop do break *[1,2]; end; assert_equal([1,2], a)
*a = *loop do break *[*[1,2]]; end; assert_equal([1,2], a)
@@ -308,7 +308,7 @@ class TestAssignment < Test::Unit::TestCase
a,b,*c = loop do break *[]; end; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = loop do break *[1]; end; assert_equal([1,nil,[]], [a,b,c])
a,b,*c = loop do break *[nil]; end; assert_equal([nil,nil,[]], [a,b,c])
- a,b,*c = loop do break *[[]]; end; assert_equal([nil,nil,[]], [a,b,c])
+ a,b,*c = loop do break *[[]]; end; assert_equal([[],nil,[]], [a,b,c])
a,b,*c = loop do break *[1,2]; end; assert_equal([1,2,[]], [a,b,c])
a,b,*c = loop do break *[*[]]; end; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = loop do break *[*[1]]; end; assert_equal([1,nil,[]], [a,b,c])
@@ -328,12 +328,12 @@ class TestAssignment < Test::Unit::TestCase
r([1]){next [*[1]]}
r([1,2]){next [*[1,2]]}
- r(nil){next *[]}
- r(1){next *[1]}
- r(nil){next *[nil]}
- r([]){next *[[]]}
- r(nil){next *[*[]]}
- r(1){next *[*[1]]}
+ r([]){next *[]}
+ r([1]){next *[1]}
+ r([nil]){next *[nil]}
+ r([[]]){next *[[]]}
+ r([]){next *[*[]]}
+ r([1]){next *[*[1]]}
r([1,2]){next *[*[1,2]]}
undef r
@@ -341,18 +341,18 @@ class TestAssignment < Test::Unit::TestCase
r([nil]){next}
r([nil]){next nil}
r([1]){next 1}
- r([[]]){next []}
- r([[1]]){next [1]}
- r([[nil]]){next [nil]}
- r([[[]]]){next [[]]}
- r([[1,2]]){next [1,2]}
- r([[]]){next [*[]]}
- r([[1]]){next [*[1]]}
- r([[1,2]]){next [*[1,2]]}
+ r([]){next []}
+ r([1]){next [1]}
+ r([nil]){next [nil]}
+ r([[]]){next [[]]}
+ r([1,2]){next [1,2]}
+ r([]){next [*[]]}
+ r([1]){next [*[1]]}
+ r([1,2]){next [*[1,2]]}
undef r
def r(val); *a = *yield(); assert_equal(val, a); end
- r([]){next *[[]]}
+ r([[]]){next *[[]]}
r([1,2]){next *[1,2]}
r([1,2]){next *[*[1,2]]}
undef r
@@ -372,7 +372,7 @@ class TestAssignment < Test::Unit::TestCase
undef r
def r(val); a,b,*c = *yield(); assert_equal(val, [a,b,c]); end
- r([nil,nil,[]]){next *[[]]}
+ r([[],nil,[]]){next *[[]]}
r([1,2,[]]){next *[1,2]}
r([1,2,[]]){next *[*[1,2]]}
undef r
diff --git a/test/ruby/test_clone.rb b/test/ruby/test_clone.rb
index 43c0cffa1d..67d79fb8a5 100644
--- a/test/ruby/test_clone.rb
+++ b/test/ruby/test_clone.rb
@@ -23,6 +23,6 @@ class TestClone < Test::Unit::TestCase
assert_raises(NoMethodError) {foo.test2}
- assert_equal([M003, M002, M001], M003.ancestors)
+ assert_equal([M003, M002, M001, M002], M003.ancestors)
end
end
diff --git a/test/ruby/test_dir.rb b/test/ruby/test_dir.rb
index 09685bee8f..7887d37670 100644
--- a/test/ruby/test_dir.rb
+++ b/test/ruby/test_dir.rb
@@ -31,9 +31,9 @@ class TestDir < Test::Unit::TestCase
break unless name = dir.read
cache << [pos, name]
end
- for x in cache.sort_by {|x| x[0] % 3 } # shuffle
- dir.seek(x[0])
- assert_equal(x[1], dir.read)
+ for x,y in cache.sort_by {|x| x[0] % 3 } # shuffle
+ dir.seek(x)
+ assert_equal(y, dir.read)
end
ensure
dir.close
diff --git a/test/ruby/test_file.rb b/test/ruby/test_file.rb
index 4947e081c5..e326b97b07 100644
--- a/test/ruby/test_file.rb
+++ b/test/ruby/test_file.rb
@@ -88,7 +88,7 @@ class TestFile < Test::Unit::TestCase
assert_nil(f.getc)
open(f.path, "w") {|g| g.print "a" }
result = []
- f.each_byte {|b| result << b }
+ f.each_byte {|b| result << b.chr }
assert_equal([?a], result)
end
diff --git a/test/ruby/test_float.rb b/test/ruby/test_float.rb
index 63979b5be0..c2e5041a21 100644
--- a/test/ruby/test_float.rb
+++ b/test/ruby/test_float.rb
@@ -87,4 +87,32 @@ class TestFloat < Test::Unit::TestCase
assert_raise(ArgumentError){Float("1e")}
# add expected behaviour here.
end
+
+ def test_divmod
+ assert_equal([2, 3.5], 11.5.divmod(4))
+ assert_equal([-3, -0.5], 11.5.divmod(-4))
+ assert_equal([-3, 0.5], (-11.5).divmod(4))
+ assert_equal([2, -3.5], (-11.5).divmod(-4))
+ end
+
+ def test_div
+ assert_equal(2, 11.5.div(4))
+ assert_equal(-3, 11.5.div(-4))
+ assert_equal(-3, (-11.5).div(4))
+ assert_equal(2, (-11.5).div(-4))
+ end
+
+ def test_modulo
+ assert_equal(3.5, 11.5.modulo(4))
+ assert_equal(-0.5, 11.5.modulo(-4))
+ assert_equal(0.5, (-11.5).modulo(4))
+ assert_equal(-3.5, (-11.5).modulo(-4))
+ end
+
+ def test_remainder
+ assert_equal(3.5, 11.5.remainder(4))
+ assert_equal(3.5, 11.5.remainder(-4))
+ assert_equal(-3.5, (-11.5).remainder(4))
+ assert_equal(-3.5, (-11.5).remainder(-4))
+ end
end
diff --git a/test/ruby/test_iterator.rb b/test/ruby/test_iterator.rb
index 81f02263a8..65e2967e62 100644
--- a/test/ruby/test_iterator.rb
+++ b/test/ruby/test_iterator.rb
@@ -151,21 +151,21 @@ class TestIterator < Test::Unit::TestCase
IterTest.new([2]).each2 {|x| assert_equal([2], x)}
IterTest.new([4]).each4 {|x| assert_equal(4, x)}
IterTest.new([5]).each5 {|x| assert_equal(5, x)}
- IterTest.new([6]).each6 {|x| assert_equal([6], x)}
+ IterTest.new([6]).each6 {|x| assert_equal(6, x)}
IterTest.new([8]).each8 {|x| assert_equal(8, x)}
- IterTest.new([[0]]).each0 {|x| assert_equal([0], x)}
- IterTest.new([[1]]).each1 {|x| assert_equal([1], x)}
- IterTest.new([[2]]).each2 {|x| assert_equal([[2]], x)}
+ IterTest.new([[0]]).each0 {|x| assert_equal(0, x)}
+ IterTest.new([[1]]).each1 {|x| assert_equal(1, x)}
+ IterTest.new([[2]]).each2 {|x| assert_equal([2], x)}
IterTest.new([[3]]).each3 {|x| assert_equal(3, x)}
- IterTest.new([[4]]).each4 {|x| assert_equal([4], x)}
- IterTest.new([[5]]).each5 {|x| assert_equal([5], x)}
- IterTest.new([[6]]).each6 {|x| assert_equal([[6]], x)}
+ IterTest.new([[4]]).each4 {|x| assert_equal(4, x)}
+ IterTest.new([[5]]).each5 {|x| assert_equal(5, x)}
+ IterTest.new([[6]]).each6 {|x| assert_equal(6, x)}
IterTest.new([[7]]).each7 {|x| assert_equal(7, x)}
- IterTest.new([[8]]).each8 {|x| assert_equal([8], x)}
+ IterTest.new([[8]]).each8 {|x| assert_equal(8, x)}
- IterTest.new([[0,0]]).each0 {|x| assert_equal([0,0], x)}
- IterTest.new([[8,8]]).each8 {|x| assert_equal([8,8], x)}
+ IterTest.new([[0,0]]).each0 {|*x| assert_equal([0,0], x)}
+ IterTest.new([[8,8]]).each8 {|*x| assert_equal([8], x)}
end
def m(var)
@@ -346,10 +346,10 @@ class TestIterator < Test::Unit::TestCase
end
def foo
- yield([:key, :value])
+ yield(:key, :value)
end
def bar(&blk)
- blk.call([:key, :value])
+ blk.call(:key, :value)
end
def test_yield_vs_call
@@ -359,14 +359,14 @@ class TestIterator < Test::Unit::TestCase
class H
def each
- yield [:key, :value]
+ yield :key, :value
end
end
def test_assoc_yield
[{:key=>:value}, H.new].each {|h|
- h.each{|a| assert_equal([:key, :value], a)}
- h.each{|*a| assert_equal([[:key, :value]], a)}
+ h.each{|a| assert_equal(:key, a)}
+ h.each{|*a| assert_equal([:key, :value], a)}
h.each{|k,v| assert_equal([:key, :value], [k,v])}
}
end
diff --git a/test/ruby/test_stringchar.rb b/test/ruby/test_stringchar.rb
index 34934e87bd..c128181b2f 100644
--- a/test/ruby/test_stringchar.rb
+++ b/test/ruby/test_stringchar.rb
@@ -68,9 +68,9 @@ END
# character constants(assumes ASCII)
assert_equal(?a, "a"[0])
assert_equal(?a, ?a)
- assert_equal(1, ?\C-a)
- assert_equal(225, ?\M-a)
- assert_equal(129, ?\M-\C-a)
+ assert_equal("\1", ?\C-a)
+ assert_equal("\341", ?\M-a)
+ assert_equal("\201", ?\M-\C-a)
assert_equal(?A, "a".upcase![0])
assert_equal(?a, "A".downcase![0])
assert_equal("ABC", "abc".tr!("a-z", "A-Z"))
@@ -82,7 +82,7 @@ END
$y = [ ?a, ?b, ?c, ?d, ?e, ?f ]
$bad = false
$x.each_byte {|i|
- if i != $y.shift
+ if i.chr != $y.shift
$bad = true
break
end
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-18 11:53:43 +0000