← Back to branch summary

~ubuntu-branches/ubuntu/lucid/jruby/lucid

« back to all changes in this revision

Viewing changes to test/externals/ruby1.9/ruby/test_stringchar.rb

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Delafond
  • Date: 2009-12-09 17:30:55 UTC
  • Revision ID: james.westby@ubuntu.com-20091209173055-8ffzikq1768gywux
Tags: upstream-1.3.1
Import upstream version 1.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/externals/ruby1.9/ruby/test_stringchar.rb
 
1
require 'test/unit'
 
2
 
 
3
class TestStringchar < Test::Unit::TestCase
 
4
  def test_string
 
5
    assert_equal("abcd", "abcd")
 
6
    assert_match(/abcd/, "abcd")
 
7
    assert("abcd" === "abcd")
 
8
    # compile time string concatenation
 
9
    assert_equal("abcd", "ab" "cd")
 
10
    assert_equal("22aacd44", "#{22}aa" "cd#{44}")
 
11
    assert_equal("22aacd445566", "#{22}aa" "cd#{44}" "55" "#{66}")
 
12
    assert("abc" !~ /^$/)
 
13
    assert("abc\n" !~ /^$/)
 
14
    assert("abc" !~ /^d*$/)
 
15
    assert_equal(3, ("abc" =~ /d*$/))
 
16
    assert("" =~ /^$/)
 
17
    assert("\n" =~ /^$/)
 
18
    assert("a\n\n" =~ /^$/)
 
19
    assert("abcabc" =~ /.*a/); assert_equal("abca", $&)
 
20
    assert("abcabc" =~ /.*c/); assert_equal("abcabc", $&)
 
21
    assert("abcabc" =~ /.*?a/); assert_equal("a", $&)
 
22
    assert("abcabc" =~ /.*?c/); assert_equal("abc", $&)
 
23
    assert(/(.|\n)*?\n(b|\n)/ =~ "a\nb\n\n"); assert_equal("a\nb", $&)
 
24
 
 
25
    assert(/^(ab+)+b/ =~ "ababb"); assert_equal("ababb", $&)
 
26
    assert(/^(?:ab+)+b/ =~ "ababb"); assert_equal("ababb", $&)
 
27
    assert(/^(ab+)+/ =~ "ababb"); assert_equal("ababb", $&)
 
28
    assert(/^(?:ab+)+/ =~ "ababb"); assert_equal("ababb", $&)
 
29
 
 
30
    assert(/(\s+\d+){2}/ =~ " 1 2"); assert_equal(" 1 2", $&)
 
31
    assert(/(?:\s+\d+){2}/ =~ " 1 2"); assert_equal(" 1 2", $&)
 
32
 
 
33
    $x = <<END;
 
34
ABCD
 
35
ABCD
 
36
END
 
37
    $x.gsub!(/((.|\n)*?)B((.|\n)*?)D/m ,'\1\3')
 
38
    assert_equal("AC\nAC\n", $x)
 
39
 
 
40
    assert("foobar" =~ /foo(?=(bar)|(baz))/)
 
41
    assert("foobaz" =~ /foo(?=(bar)|(baz))/)
 
42
 
 
43
    $foo = "abc"
 
44
    assert_equal("abc = abc", "#$foo = abc")
 
45
    assert_equal("abc = abc", "#{$foo} = abc")
 
46
 
 
47
    foo = "abc"
 
48
    assert_equal("abc = abc", "#{foo} = abc")
 
49
 
 
50
    assert_equal('-----', '-' * 5)
 
51
    assert_equal('-', '-' * 1)
 
52
    assert_equal('', '-' * 0)
 
53
 
 
54
    foo = '-'
 
55
    assert_equal('-----', foo * 5)
 
56
    assert_equal('-', foo * 1)
 
57
    assert_equal('', foo * 0)
 
58
 
 
59
    $x = "a.gif"
 
60
    assert_equal("gif", $x.sub(/.*\.([^\.]+)$/, '\1'))
 
61
    assert_equal("b.gif", $x.sub(/.*\.([^\.]+)$/, 'b.\1'))
 
62
    assert_equal("", $x.sub(/.*\.([^\.]+)$/, '\2'))
 
63
    assert_equal("ab", $x.sub(/.*\.([^\.]+)$/, 'a\2b'))
 
64
    assert_equal("<a.gif>", $x.sub(/.*\.([^\.]+)$/, '<\&>'))
 
65
  end
 
66
 
 
67
  def test_char
 
68
    # character constants(assumes ASCII)
 
69
    assert_equal(?a, "a"[0])
 
70
    assert_equal(?a, ?a)
 
71
    assert_equal("\1", ?\C-a)
 
72
    assert_equal("\341", ?\M-a)
 
73
    assert_equal("\201", ?\M-\C-a)
 
74
    assert_equal(?A, "a".upcase![0])
 
75
    assert_equal(?a, "A".downcase![0])
 
76
    assert_equal("ABC", "abc".tr!("a-z", "A-Z"))
 
77
    assert_equal("ABC", "aabbcccc".tr_s!("a-z", "A-Z"))
 
78
    assert_equal("abc", "abcc".squeeze!("a-z"))
 
79
    assert_equal("ad", "abcd".delete!("bc"))
 
80
 
 
81
    $x = "abcdef"
 
82
    $y = [ ?a, ?b, ?c, ?d, ?e, ?f ]
 
83
    $bad = false
 
84
    $x.each_byte {|i|
 
85
      if i.chr != $y.shift
 
86
        $bad = true
 
87
        break
 
88
      end
 
89
    }
 
90
    assert(!$bad)
 
91
 
 
92
    s = "a string"
 
93
    s[0..s.size]="another string"
 
94
    assert_equal("another string", s)
 
95
 
 
96
    s = <<EOS
 
97
#{
 
98
[1,2,3].join(",")
 
99
}
 
100
EOS
 
101
    assert_equal("1,2,3\n", s)
 
102
    assert_equal(926381, "Just".to_i(36))
 
103
    assert_equal(-23200231779, "-another".to_i(36))
 
104
    assert_equal("ruby", 1299022.to_s(36))
 
105
    assert_equal("-hacker", -1045307475.to_s(36))
 
106
    assert_equal(265419172580680477752431643787347, "Just_another_Ruby_hacker".to_i(36))
 
107
    assert_equal("-justanotherrubyhacker", -265419172580680477752431643787347.to_s(36))
 
108
 
 
109
    a = []
 
110
    (0..255).each {|n|
 
111
      ch = [n].pack("C")
 
112
      a.push ch if /a#{Regexp.quote ch}b/x =~ "ab"
 
113
    }
 
114
    assert_equal(0, a.size)
 
115
  end
 
116
 
 
117
  def test_bang
 
118
    s = "aBc"
 
119
    s.upcase
 
120
    assert_equal("aBc", s)
 
121
    s.upcase!
 
122
    assert_equal("ABC", s)
 
123
 
 
124
    s = "aBc"
 
125
    s.downcase
 
126
    assert_equal("aBc", s)
 
127
    s.downcase!
 
128
    assert_equal("abc", s)
 
129
 
 
130
    s = "aBc"
 
131
    s.swapcase
 
132
    assert_equal("aBc", s)
 
133
    s.swapcase!
 
134
    assert_equal("AbC", s)
 
135
 
 
136
    s = "aBc"
 
137
    s.capitalize
 
138
    assert_equal("aBc", s)
 
139
    s.capitalize!
 
140
    assert_equal("Abc", s)
 
141
 
 
142
    s = "aBc"
 
143
    s.tr("a-z", "A-Z")
 
144
    assert_equal("aBc", s)
 
145
    s.tr!("a-z", "A-Z")
 
146
    assert_equal("ABC", s)
 
147
 
 
148
    s = "aaBBcc"
 
149
    s.tr_s("a-z", "A-Z")
 
150
    assert_equal("aaBBcc", s)
 
151
    s.tr_s!("a-z", "A-Z")
 
152
    assert_equal("ABBC", s)
 
153
 
 
154
    s = "aaBBcc"
 
155
    s.squeeze("a-z")
 
156
    assert_equal("aaBBcc", s)
 
157
    s.squeeze!("a-z")
 
158
    assert_equal("aBBc", s)
 
159
 
 
160
    s = "aaBBcc"
 
161
    s.delete("a-z")
 
162
    assert_equal("aaBBcc", s)
 
163
    s.delete!("a-z")
 
164
    assert_equal("BB", s)
 
165
  end
 
166
end