| ## |
| # Literals ISO Test |
| |
| assert('Literals Numerical', '8.7.6.2') do |
| # signed and unsigned integer |
| assert_equal 1, 1 |
| assert_equal(-1, -1) |
| assert_equal(+1, +1) |
| # signed and unsigned float |
| assert_equal 1.0, 1.0 |
| assert_equal(-1.0, -1.0) |
| # binary |
| assert_equal 128, 0b10000000 |
| assert_equal 128, 0B10000000 |
| # octal |
| assert_equal 8, 0o10 |
| assert_equal 8, 0O10 |
| assert_equal 8, 0_10 |
| # hex |
| assert_equal 255, 0xff |
| assert_equal 255, 0Xff |
| # decimal |
| assert_equal 999, 0d999 |
| assert_equal 999, 0D999 |
| # decimal seperator |
| assert_equal 10000000, 10_000_000 |
| assert_equal 10, 1_0 |
| # integer with exponent |
| assert_equal 10.0, 1e1 |
| assert_equal(0.1, 1e-1) |
| assert_equal 10.0, 1e+1 |
| # float with exponent |
| assert_equal 10.0, 1.0e1 |
| assert_equal(0.1, 1.0e-1) |
| assert_equal 10.0, 1.0e+1 |
| end |
| |
| assert('Literals Strings Single Quoted', '8.7.6.3.2') do |
| assert_equal 'abc', 'abc' |
| assert_equal '\'', '\'' |
| assert_equal '\\', '\\' |
| end |
| |
| assert('Literals Strings Double Quoted', '8.7.6.3.3') do |
| a = "abc" |
| |
| assert_equal "abc", "abc" |
| assert_equal "\"", "\"" |
| assert_equal "\\", "\\" |
| assert_equal "abc", "#{a}" |
| end |
| |
| assert('Literals Strings Quoted Non-Expanded', '8.7.6.3.4') do |
| a = %q{abc} |
| b = %q(abc) |
| c = %q[abc] |
| d = %q<abc> |
| e = %q/abc/ |
| f = %q/ab\/c/ |
| g = %q{#{a}} |
| |
| assert_equal 'abc', a |
| assert_equal 'abc', b |
| assert_equal 'abc', c |
| assert_equal 'abc', d |
| assert_equal 'abc', e |
| assert_equal 'ab/c', f |
| assert_equal '#{a}', g |
| end |
| |
| assert('Literals Strings Quoted Expanded', '8.7.6.3.5') do |
| a = %Q{abc} |
| b = %Q(abc) |
| c = %Q[abc] |
| d = %Q<abc> |
| e = %Q/abc/ |
| f = %Q/ab\/c/ |
| g = %Q{#{a}} |
| |
| assert_equal 'abc', a |
| assert_equal 'abc', b |
| assert_equal 'abc', c |
| assert_equal 'abc', d |
| assert_equal 'abc', e |
| assert_equal 'ab/c', f |
| assert_equal 'abc', g |
| end |
| |
| assert('Literals Strings Here documents', '8.7.6.3.6') do |
| a = <<AAA |
| aaa |
| AAA |
| b = <<b_b |
| bbb |
| b_b |
| c = [<<CCC1, <<"CCC2", <<'CCC3'] |
| c1 |
| CCC1 |
| c 2 |
| CCC2 |
| c 3 |
| CCC3 |
| |
| d = <<DDD |
| d#{1+2}DDD |
| d\t |
| DDD\n |
| DDD |
| e = <<'EEE' |
| e#{1+2}EEE |
| e\t |
| EEE\n |
| EEE |
| f = <<"FFF" |
| F |
| FF#{"f"}FFF |
| F |
| FFF |
| |
| g = <<-GGG |
| ggg |
| GGG |
| h = <<-"HHH" |
| hhh |
| HHH |
| i = <<-'III' |
| iii |
| III |
| j = [<<-JJJ1 , <<-"JJJ2" , <<-'JJJ3' ] |
| j#{1}j |
| JJJ1 |
| j#{2}j |
| JJJ2 |
| j#{3}j |
| JJJ3 |
| |
| k = <<'KKK'.to_i |
| 123 |
| KKK |
| |
| m = [<<MM1, <<MM2] |
| x#{m2 = {x:<<MM3}}y |
| mm3 |
| MM3 |
| mm1 |
| MM1 |
| mm2 |
| MM2 |
| |
| n = [1, "#{<<NN1}", 3, |
| nn1 |
| NN1 |
| 4] |
| |
| qqq = Proc.new {|*x| x.join(' $ ')} |
| q1 = qqq.call("a", <<QQ1, "c", |
| q |
| QQ1 |
| "d") |
| q2 = qqq.call("l", "m#{<<QQ2}n", |
| qq |
| QQ2 |
| "o") |
| |
| w = %W( 1 #{<<WWW} 3 |
| www |
| WWW |
| 4 5 ) |
| |
| x = [1, <<XXX1, |
| foo #{<<XXX2} bar |
| 222 #{<<XXX3} 444 |
| 333 |
| XXX3 |
| 5 |
| XXX2 |
| 6 |
| XXX1 |
| 9] |
| |
| z = <<'ZZZ' |
| ZZZ |
| |
| assert_equal "aaa\n", a |
| assert_equal "bbb\n", b |
| assert_equal ["c1\n", "c 2\n", "c 3\n"], c |
| assert_equal "d3DDD\nd\t\nDDD\n\n", d |
| assert_equal "e\#{1+2}EEE\ne\\t\nEEE\\n\n", e |
| assert_equal "F\nFFfFFF\nF\n", f |
| assert_equal " ggg\n", g |
| assert_equal " hhh\n", h |
| assert_equal " iii\n", i |
| assert_equal [" j1j\n", " j2j\n", " j\#{3}j\n"], j |
| assert_equal 123, k |
| assert_equal ["x{:x=>\"mm3\\n\"}y\nmm1\n", "mm2\n"], m |
| assert_equal ({:x=>"mm3\n"}), m2 |
| assert_equal [1, "nn1\n", 3, 4], n |
| assert_equal "a $ q\n $ c $ d", q1 |
| assert_equal "l $ mqq\nn $ o", q2 |
| assert_equal ["1", "www\n", "3", "4", "5"], w |
| assert_equal [1, "foo 222 333\n 444\n5\n bar\n6\n", 9], x |
| assert_equal "", z |
| |
| end |
| |
| |
| assert('Literals Array', '8.7.6.4') do |
| a = %W{abc#{1+2}def \}g} |
| b = %W(abc #{2+3} def \(g) |
| c = %W[#{3+4}] |
| d = %W< #{4+5} > |
| e = %W// |
| f = %W[[ab cd][ef]] |
| g = %W{ |
| ab |
| #{-1}1 |
| 2#{2} |
| } |
| h = %W(a\nb |
| test\ abc |
| c\ |
| d |
| x\y x\\y x\\\y) |
| |
| assert_equal ['abc3def', '}g'], a |
| assert_equal ['abc', '5', 'def', '(g'], b |
| assert_equal ['7'],c |
| assert_equal ['9'], d |
| assert_equal [], e |
| assert_equal ['[ab', 'cd][ef]'], f |
| assert_equal ['ab', '-11', '22'], g |
| assert_equal ["a\nb", 'test abc', "c\nd", "xy", "x\\y", "x\\y"], h |
| |
| a = %w{abc#{1+2}def \}g} |
| b = %w(abc #{2+3} def \(g) |
| c = %w[#{3+4}] |
| d = %w< #{4+5} > |
| e = %w// |
| f = %w[[ab cd][ef]] |
| g = %w{ |
| ab |
| #{-1}1 |
| 2#{2} |
| } |
| h = %w(a\nb |
| test\ abc |
| c\ |
| d |
| x\y x\\y x\\\y) |
| |
| assert_equal ['abc#{1+2}def', '}g'], a |
| assert_equal ['abc', '#{2+3}', 'def', '(g'], b |
| assert_equal ['#{3+4}'], c |
| assert_equal ['#{4+5}'], d |
| assert_equal [], e |
| assert_equal ['[ab', 'cd][ef]'], f |
| assert_equal ['ab', '#{-1}1', '2#{2}'], g |
| assert_equal ["a\\nb", "test abc", "c\nd", "x\\y", "x\\y", "x\\\\y"], h |
| end |
| |
| |
| assert('Literals Array of symbols') do |
| a = %I{abc#{1+2}def \}g} |
| b = %I(abc #{2+3} def \(g) |
| c = %I[#{3+4}] |
| d = %I< #{4+5} > |
| e = %I// |
| f = %I[[ab cd][ef]] |
| g = %I{ |
| ab |
| #{-1}1 |
| 2#{2} |
| } |
| |
| assert_equal [:'abc3def', :'}g'], a |
| assert_equal [:'abc', :'5', :'def', :'(g'], b |
| assert_equal [:'7'],c |
| assert_equal [:'9'], d |
| assert_equal [], e |
| assert_equal [:'[ab', :'cd][ef]'], f |
| assert_equal [:'ab', :'-11', :'22'], g |
| |
| a = %i{abc#{1+2}def \}g} |
| b = %i(abc #{2+3} def \(g) |
| c = %i[#{3+4}] |
| d = %i< #{4+5} > |
| e = %i// |
| f = %i[[ab cd][ef]] |
| g = %i{ |
| ab |
| #{-1}1 |
| 2#{2} |
| } |
| |
| assert_equal [:'abc#{1+2}def', :'}g'], a |
| assert_equal [:'abc', :'#{2+3}', :'def', :'(g'], b |
| assert_equal [:'#{3+4}'], c |
| assert_equal [:'#{4+5}'], d |
| assert_equal [] ,e |
| assert_equal [:'[ab', :'cd][ef]'], f |
| assert_equal [:'ab', :'#{-1}1', :'2#{2}'], g |
| end |
| |
| assert('Literals Symbol', '8.7.6.6') do |
| # do not compile error |
| :$asd |
| :@asd |
| :@@asd |
| :asd= |
| :asd! |
| :asd? |
| :+ |
| :+@ |
| :if |
| :BEGIN |
| |
| a = :"asd qwe" |
| b = :'foo bar' |
| c = :"a#{1+2}b" |
| d = %s(asd) |
| e = %s( foo \)) |
| f = %s[asd \[ |
| qwe] |
| g = %s/foo#{1+2}bar/ |
| h = %s{{foo bar}} |
| |
| assert_equal :'asd qwe', a |
| assert_equal :"foo bar", b |
| assert_equal :a3b, c |
| assert_equal :asd, d |
| assert_equal :' foo )', e |
| assert_equal :"asd [\nqwe", f |
| assert_equal :'foo#{1+2}bar', g |
| assert_equal :'{foo bar}', h |
| end |
| |
| # Not Implemented ATM assert('Literals Regular expression', '8.7.6.5') do |