diff options
Diffstat (limited to 'test')
36 files changed, 130 insertions, 696 deletions
diff --git a/test/-ext-/string/test_fstring.rb b/test/-ext-/string/test_fstring.rb index 71b12e9cce..d51bb033d3 100644 --- a/test/-ext-/string/test_fstring.rb +++ b/test/-ext-/string/test_fstring.rb @@ -12,36 +12,6 @@ class Test_String_Fstring < Test::Unit::TestCase yield fstr end - def test_taint_shared_string - str = __method__.to_s.dup - str.taint - assert_fstring(str) {|s| assert_predicate(s, :tainted?)} - end - - def test_taint_normal_string - str = __method__.to_s * 3 - str.taint - assert_fstring(str) {|s| assert_predicate(s, :tainted?)} - end - - def test_taint_registered_tainted - str = __method__.to_s * 3 - str.taint - assert_fstring(str) {|s| assert_predicate(s, :tainted?)} - - str = __method__.to_s * 3 - assert_fstring(str) {|s| assert_not_predicate(s, :tainted?)} - end - - def test_taint_registered_untainted - str = __method__.to_s * 3 - assert_fstring(str) {|s| assert_not_predicate(s, :tainted?)} - - str = __method__.to_s * 3 - str.taint - assert_fstring(str) {|s| assert_predicate(s, :tainted?)} - end - def test_instance_variable str = __method__.to_s * 3 str.instance_variable_set(:@test, 42) diff --git a/test/-ext-/test_printf.rb b/test/-ext-/test_printf.rb index feaeadd975..cfec388e8c 100644 --- a/test/-ext-/test_printf.rb +++ b/test/-ext-/test_printf.rb @@ -35,15 +35,6 @@ class Test_SPrintf < Test::Unit::TestCase assert_equal("<\u{3042 3044 3046 3048 304a}>", Bug::Printf.s(self)) end - def test_taint - obj = Object.new.taint - assert_equal({to_s: true, inspect: true}, - { - to_s: Bug::Printf.s(obj).tainted?, - inspect: Bug::Printf.v(obj).tainted?, - }) - end - VS = [ #-0x1000000000000000000000000000000000000000000000002, #-0x1000000000000000000000000000000000000000000000001, diff --git a/test/bigdecimal/test_bigdecimal.rb b/test/bigdecimal/test_bigdecimal.rb index dff390b0cc..f6ef88e3f5 100644 --- a/test/bigdecimal/test_bigdecimal.rb +++ b/test/bigdecimal/test_bigdecimal.rb @@ -155,6 +155,15 @@ class TestBigDecimal < Test::Unit::TestCase end end + def test_BigDecimal_with_tainted_string + Thread.new { + $SAFE = 1 + BigDecimal('1'.taint) + }.join + ensure + $SAFE = 0 + end + def test_BigDecimal_with_exception_keyword assert_raise(ArgumentError) { BigDecimal('.', exception: true) diff --git a/test/cgi/test_cgi_util.rb b/test/cgi/test_cgi_util.rb index fa1c1e5959..b7bb7b8eae 100644 --- a/test/cgi/test_cgi_util.rb +++ b/test/cgi/test_cgi_util.rb @@ -99,13 +99,6 @@ class CGIUtilTest < Test::Unit::TestCase end end - def test_cgi_escape_html_preserve_tainted - assert_not_predicate CGI.escapeHTML("'&\"><"), :tainted? - assert_predicate CGI.escapeHTML("'&\"><".dup.taint), :tainted? - assert_not_predicate CGI.escapeHTML("Ruby"), :tainted? - assert_predicate CGI.escapeHTML("Ruby".dup.taint), :tainted? - end - def test_cgi_escape_html_dont_freeze assert_not_predicate CGI.escapeHTML("'&\"><".dup), :frozen? assert_not_predicate CGI.escapeHTML("'&\"><".freeze), :frozen? diff --git a/test/drb/test_drb.rb b/test/drb/test_drb.rb index 15e40ac596..9242a22543 100644 --- a/test/drb/test_drb.rb +++ b/test/drb/test_drb.rb @@ -103,15 +103,6 @@ module DRbYield @there.xarray_each {|x| assert_kind_of(XArray, x)} @there.xarray_each {|*x| assert_kind_of(XArray, x[0])} end - - def test_06_taint - x = proc {} - assert_not_predicate(x, :tainted?) - @there.echo_yield(x) {|o| - assert_equal(x, o) - assert_not_predicate(x, :tainted?) - } - end end class TestDRbYield < Test::Unit::TestCase diff --git a/test/fiddle/test_func.rb b/test/fiddle/test_func.rb index ca89173766..d170c59a75 100644 --- a/test/fiddle/test_func.rb +++ b/test/fiddle/test_func.rb @@ -11,6 +11,18 @@ module Fiddle assert_nil f.call(10) end + def test_syscall_with_tainted_string + f = Function.new(@libc['system'], [TYPE_VOIDP], TYPE_INT) + Thread.new { + $SAFE = 1 + assert_raise(SecurityError) do + f.call("uname -rs".dup.taint) + end + }.join + ensure + $SAFE = 0 + end + def test_sinf begin f = Function.new(@libm['sinf'], [TYPE_FLOAT], TYPE_FLOAT) diff --git a/test/fiddle/test_handle.rb b/test/fiddle/test_handle.rb index 17f9c92a11..c0fac39908 100644 --- a/test/fiddle/test_handle.rb +++ b/test/fiddle/test_handle.rb @@ -8,6 +8,29 @@ module Fiddle class TestHandle < TestCase include Fiddle + def test_safe_handle_open + Thread.new do + $SAFE = 1 + assert_raise(SecurityError) { + Fiddle::Handle.new(LIBC_SO.dup.taint) + } + end.join + ensure + $SAFE = 0 + end + + def test_safe_function_lookup + Thread.new do + h = Fiddle::Handle.new(LIBC_SO) + $SAFE = 1 + assert_raise(SecurityError) { + h["qsort".dup.taint] + } + end.join + ensure + $SAFE = 0 + end + def test_to_i handle = Fiddle::Handle.new(LIBC_SO) assert_kind_of Integer, handle.to_i diff --git a/test/net/imap/test_imap_response_parser.rb b/test/net/imap/test_imap_response_parser.rb index 5c2d54566d..4e470459c9 100644 --- a/test/net/imap/test_imap_response_parser.rb +++ b/test/net/imap/test_imap_response_parser.rb @@ -24,13 +24,13 @@ class IMAPResponseParserTest < Test::Unit::TestCase parser = Net::IMAP::ResponseParser.new assert_nothing_raised do 3.times do |i| - parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + parser.parse(<<EOF.gsub(/\n/, "\r\n")) * LIST (\\Foo#{i}) "." "INBOX" EOF end end assert_raise(Net::IMAP::FlagCountError) do - parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + parser.parse(<<EOF.gsub(/\n/, "\r\n")) * LIST (\\Foo3) "." "INBOX" EOF end @@ -40,7 +40,7 @@ EOF parser = Net::IMAP::ResponseParser.new assert_nothing_raised do 100.times do - parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + parser.parse(<<EOF.gsub(/\n/, "\r\n")) * LIST (\\Foo) "." "INBOX" EOF end @@ -49,7 +49,7 @@ EOF def test_flag_xlist_inbox parser = Net::IMAP::ResponseParser.new - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * XLIST (\\Inbox) "." "INBOX" EOF assert_equal [:Inbox], response.data.attr @@ -57,7 +57,7 @@ EOF def test_resp_text_code parser = Net::IMAP::ResponseParser.new - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * OK [CLOSED] Previous mailbox closed. EOF assert_equal "CLOSED", response.data.code.name @@ -65,15 +65,15 @@ EOF def test_search_response parser = Net::IMAP::ResponseParser.new - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * SEARCH EOF assert_equal [], response.data - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * SEARCH 1 EOF assert_equal [1], response.data - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * SEARCH 1 2 3 EOF assert_equal [1, 2, 3], response.data @@ -81,11 +81,11 @@ EOF def test_search_response_of_yahoo parser = Net::IMAP::ResponseParser.new - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * SEARCH 1\s EOF assert_equal [1], response.data - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * SEARCH 1 2 3\s EOF assert_equal [1, 2, 3], response.data @@ -93,12 +93,12 @@ EOF def test_msg_att_extra_space parser = Net::IMAP::ResponseParser.new - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * 1 FETCH (UID 92285) EOF assert_equal 92285, response.data.attr["UID"] - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * 1 FETCH (UID 92285 ) EOF assert_equal 92285, response.data.attr["UID"] @@ -107,7 +107,7 @@ EOF def test_msg_att_parse_error parser = Net::IMAP::ResponseParser.new e = assert_raise(Net::IMAP::ResponseParseError) { - parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + parser.parse(<<EOF.gsub(/\n/, "\r\n")) * 123 FETCH (UNKNOWN 92285) EOF } @@ -116,13 +116,13 @@ EOF def test_msg_att_rfc822_text parser = Net::IMAP::ResponseParser.new - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * 123 FETCH (RFC822 {5} foo ) EOF assert_equal("foo\r\n", response.data.attr["RFC822"]) - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * 123 FETCH (RFC822[] {5} foo ) @@ -133,7 +133,7 @@ EOF # [Bug #6397] [ruby-core:44849] def test_body_type_attachment parser = Net::IMAP::ResponseParser.new - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * 980 FETCH (UID 2862 BODYSTRUCTURE ((("TEXT" "PLAIN" ("CHARSET" "iso-8859-1") NIL NIL "7BIT" 416 21 NIL NIL NIL)("TEXT" "HTML" ("CHARSET" "iso-8859-1") NIL NIL "7BIT" 1493 32 NIL NIL NIL) "ALTERNATIVE" ("BOUNDARY" "Boundary_(ID_IaecgfnXwG5bn3x8lIeGIQ)") NIL NIL)("MESSAGE" "RFC822" ("NAME" "Fw_ ____ _____ ____.eml") NIL NIL "7BIT" 1980088 NIL ("ATTACHMENT" ("FILENAME" "Fw_ ____ _____ ____.eml")) NIL) "MIXED" ("BOUNDARY" "Boundary_(ID_eDdLc/j0mBIzIlR191pHjA)") NIL NIL)) EOF assert_equal("Fw_ ____ _____ ____.eml", @@ -142,7 +142,7 @@ EOF def assert_parseable(s) parser = Net::IMAP::ResponseParser.new - parser.parse(s.gsub(/\n/, "\r\n").taint) + parser.parse(s.gsub(/\n/, "\r\n")) end # [Bug #7146] @@ -171,7 +171,7 @@ EOF # [Bug #8167] def test_msg_delivery_status_with_extra_data parser = Net::IMAP::ResponseParser.new - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * 29021 FETCH (RFC822.SIZE 3162 UID 113622 RFC822.HEADER {1155} Return-path: <> Envelope-to: info@xxxxxxxx.si @@ -214,7 +214,7 @@ EOF # [Bug #8281] def test_acl parser = Net::IMAP::ResponseParser.new - response = parser.parse(<<EOF.gsub(/\n/, "\r\n").taint) + response = parser.parse(<<EOF.gsub(/\n/, "\r\n")) * ACL "INBOX/share" "imshare2copy1366146467@xxxxxxxxxxxxxxxxxx.com" lrswickxteda EOF assert_equal("ACL", response.name) diff --git a/test/pathname/test_pathname.rb b/test/pathname/test_pathname.rb index 4d480a50f3..792510bdfb 100644 --- a/test/pathname/test_pathname.rb +++ b/test/pathname/test_pathname.rb @@ -592,39 +592,6 @@ class TestPathname < Test::Unit::TestCase assert_raise(ArgumentError) { Pathname.new("\0") } end - def test_taint - obj = Pathname.new("a"); assert_same(obj, obj.taint) - obj = Pathname.new("a"); assert_same(obj, obj.untaint) - - assert_equal(false, Pathname.new("a" ) .tainted?) - assert_equal(false, Pathname.new("a" ) .to_s.tainted?) - assert_equal(true, Pathname.new("a" ).taint .tainted?) - assert_equal(true, Pathname.new("a" ).taint.to_s.tainted?) - assert_equal(true, Pathname.new("a".dup.taint) .tainted?) - assert_equal(true, Pathname.new("a".dup.taint) .to_s.tainted?) - assert_equal(true, Pathname.new("a".dup.taint).taint .tainted?) - assert_equal(true, Pathname.new("a".dup.taint).taint.to_s.tainted?) - - str = "a".dup - path = Pathname.new(str) - str.taint - assert_equal(false, path .tainted?) - assert_equal(false, path.to_s.tainted?) - end - - def test_untaint - obj = Pathname.new("a"); assert_same(obj, obj.untaint) - - assert_equal(false, Pathname.new("a").taint.untaint .tainted?) - assert_equal(false, Pathname.new("a").taint.untaint.to_s.tainted?) - - str = "a".dup.taint - path = Pathname.new(str) - str.untaint - assert_equal(true, path .tainted?) - assert_equal(true, path.to_s.tainted?) - end - def test_freeze obj = Pathname.new("a"); assert_same(obj, obj.freeze) @@ -638,20 +605,6 @@ class TestPathname < Test::Unit::TestCase assert_equal(false, Pathname.new("a".freeze).freeze.to_s.frozen?) end - def test_freeze_and_taint - obj = Pathname.new("a") - obj.freeze - assert_equal(false, obj.tainted?) - assert_raise(FrozenError) { obj.taint } - - obj = Pathname.new("a") - obj.taint - assert_equal(true, obj.tainted?) - obj.freeze - assert_equal(true, obj.tainted?) - assert_nothing_raised { obj.taint } - end - def test_to_s str = "a" obj = Pathname.new(str) diff --git a/test/readline/test_readline.rb b/test/readline/test_readline.rb index f87435498c..4e82d46d91 100644 --- a/test/readline/test_readline.rb +++ b/test/readline/test_readline.rb @@ -41,6 +41,21 @@ module BasetestReadline assert_equal("> ", stdout.read(2)) assert_equal(1, Readline::HISTORY.length) assert_equal("hello", Readline::HISTORY[0]) + + # Work around lack of SecurityError in Reline + # test mode with tainted prompt + return if kind_of?(TestRelineAsReadline) + + Thread.start { + $SAFE = 1 + assert_raise(SecurityError) do + replace_stdio(stdin.path, stdout.path) do + Readline.readline("> ".taint) + end + end + }.join + ensure + $SAFE = 0 end end diff --git a/test/rss/test_parser.rb b/test/rss/test_parser.rb index 4e7cc1b963..19344a0643 100644 --- a/test/rss/test_parser.rb +++ b/test/rss/test_parser.rb @@ -19,7 +19,7 @@ EOR @rss_tmp = Tempfile.new(%w"rss10- .rdf") @rss_tmp.print(@rss10) @rss_tmp.close - @rss_file = @rss_tmp.path.untaint + @rss_file = @rss_tmp.path end def teardown diff --git a/test/ruby/test_array.rb b/test/ruby/test_array.rb index 6d730db4ae..476cf795f0 100644 --- a/test/ruby/test_array.rb +++ b/test/ruby/test_array.rb @@ -556,18 +556,14 @@ class TestArray < Test::Unit::TestCase end def test_clone - for taint in [ false, true ] - for frozen in [ false, true ] - a = @cls[*(0..99).to_a] - a.taint if taint - a.freeze if frozen - b = a.clone - - assert_equal(a, b) - assert_not_equal(a.__id__, b.__id__) - assert_equal(a.frozen?, b.frozen?) - assert_equal(a.tainted?, b.tainted?) - end + for frozen in [ false, true ] + a = @cls[*(0..99).to_a] + a.freeze if frozen + b = a.clone + + assert_equal(a, b) + assert_not_equal(a.__id__, b.__id__) + assert_equal(a.frozen?, b.frozen?) end end @@ -754,18 +750,14 @@ class TestArray < Test::Unit::TestCase end def test_dup - for taint in [ false, true ] - for frozen in [ false, true ] - a = @cls[*(0..99).to_a] - a.taint if taint - a.freeze if frozen - b = a.dup - - assert_equal(a, b) - assert_not_equal(a.__id__, b.__id__) - assert_equal(false, b.frozen?) - assert_equal(a.tainted?, b.tainted?) - end + for frozen in [ false, true ] + a = @cls[*(0..99).to_a] + a.freeze if frozen + b = a.dup + + assert_equal(a, b) + assert_not_equal(a.__id__, b.__id__) + assert_equal(false, b.frozen?) end end @@ -865,13 +857,6 @@ class TestArray < Test::Unit::TestCase assert_raise(TypeError, "[ruby-dev:31197]") { [[]].flatten("") } end - def test_flatten_taint - a6 = @cls[[1, 2], 3] - a6.taint - a7 = a6.flatten - assert_equal(true, a7.tainted?) - end - def test_flatten_level0 a8 = @cls[[1, 2], 3] a9 = a8.flatten(0) @@ -1132,20 +1117,6 @@ class TestArray < Test::Unit::TestCase assert_equal("1,2,3", a.join(',')) $, = "" - a = @cls[1, 2, 3] - a.taint - s = a.join - assert_equal(true, s.tainted?) - - bug5902 = '[ruby-core:42161]' - sep = ":".taint - - s = @cls[].join(sep) - assert_equal(false, s.tainted?, bug5902) - s = @cls[1].join(sep) - assert_equal(false, s.tainted?, bug5902) - s = @cls[1, 2].join(sep) - assert_equal(true, s.tainted?, bug5902) e = ''.force_encoding('EUC-JP') u = ''.force_encoding('UTF-8') @@ -2899,13 +2870,6 @@ class TestArray < Test::Unit::TestCase assert_equal(Array2, Array2[*(1..100)][1..99].class) #not embedded end - def test_inspect - a = @cls[1, 2, 3] - a.taint - s = a.inspect - assert_equal(true, s.tainted?) - end - def test_initialize2 a = [1] * 1000 a.instance_eval { initialize } diff --git a/test/ruby/test_econv.rb b/test/ruby/test_econv.rb index 115ff73ea8..a469614d84 100644 --- a/test/ruby/test_econv.rb +++ b/test/ruby/test_econv.rb @@ -685,7 +685,6 @@ class TestEncodingConverter < Test::Unit::TestCase ec = Encoding::Converter.new("utf-8", "euc-jp") assert_raise(Encoding::InvalidByteSequenceError) { ec.convert("a\x80") } assert_raise(Encoding::UndefinedConversionError) { ec.convert("\ufffd") } - assert_predicate(ec.convert("abc".taint), :tainted?) ret = ec.primitive_convert(nil, "", nil, nil) assert_equal(:finished, ret) assert_raise(ArgumentError) { ec.convert("a") } diff --git a/test/ruby/test_encoding.rb b/test/ruby/test_encoding.rb index a088fe1aa4..40fd302c07 100644 --- a/test/ruby/test_encoding.rb +++ b/test/ruby/test_encoding.rb @@ -34,9 +34,6 @@ class TestEncoding < Test::Unit::TestCase assert_raise(TypeError) { e.dup } assert_raise(TypeError) { e.clone } assert_equal(e.object_id, Marshal.load(Marshal.dump(e)).object_id) - assert_not_predicate(e, :tainted?) - Marshal.load(Marshal.dump(e).taint) - assert_not_predicate(e, :tainted?, '[ruby-core:71793] [Bug #11760]') end end diff --git a/test/ruby/test_env.rb b/test/ruby/test_env.rb index b01c3b12ee..d9301ff76c 100644 --- a/test/ruby/test_env.rb +++ b/test/ruby/test_env.rb @@ -46,7 +46,6 @@ class TestEnv < Test::Unit::TestCase end ENV['TEST'] = 'bar' assert_equal('bar', ENV['TEST']) - assert_predicate(ENV['TEST'], :tainted?) if IGNORE_CASE assert_equal('bar', ENV['test']) else @@ -113,7 +112,6 @@ class TestEnv < Test::Unit::TestCase assert_invalid_env {|v| ENV[v]} ENV[PATH_ENV] = "" assert_equal("", ENV[PATH_ENV]) - assert_predicate(ENV[PATH_ENV], :tainted?) assert_nil(ENV[""]) end @@ -136,7 +134,6 @@ class TestEnv < Test::Unit::TestCase assert_nothing_raised { ENV.fetch(PATH_ENV, "foo") } ENV[PATH_ENV] = "" assert_equal("", ENV.fetch(PATH_ENV)) - assert_predicate(ENV.fetch(PATH_ENV), :tainted?) end def test_aset @@ -154,9 +151,6 @@ class TestEnv < Test::Unit::TestCase assert_equal("test", ENV["foo"]) rescue Errno::EINVAL end - - ENV[PATH_ENV] = "/tmp/".taint - assert_equal("/tmp/", ENV[PATH_ENV]) end def test_keys @@ -364,7 +358,6 @@ class TestEnv < Test::Unit::TestCase assert_equal("foo", v) end assert_invalid_env {|var| ENV.assoc(var)} - assert_predicate(v, :tainted?) assert_equal(Encoding.find("locale"), v.encoding) end diff --git a/test/ruby/test_exception.rb b/test/ruby/test_exception.rb index 442a36b2fd..05cc109b48 100644 --- a/test/ruby/test_exception.rb +++ b/test/ruby/test_exception.rb @@ -550,28 +550,6 @@ end.join end end - def test_to_s_taintness_propagation - for exc in [Exception, NameError] - m = "abcdefg" - e = exc.new(m) - e.taint - s = e.to_s - assert_equal(false, m.tainted?, - "#{exc}#to_s should not propagate taintness") - assert_equal(false, s.tainted?, - "#{exc}#to_s should not propagate taintness") - end - - o = Object.new - def o.to_str - "foo" - end - o.taint - e = NameError.new(o) - s = e.to_s - assert_equal(false, s.tainted?) - end - def m m(&->{return 0}) 42 diff --git a/test/ruby/test_file.rb b/test/ruby/test_file.rb index 5599040e1e..9153298fd0 100644 --- a/test/ruby/test_file.rb +++ b/test/ruby/test_file.rb @@ -287,26 +287,6 @@ class TestFile < Test::Unit::TestCase } end - def test_realpath_taintedness - Dir.mktmpdir('rubytest-realpath') {|tmpdir| - dir = File.realpath(tmpdir).untaint - File.write(File.join(dir, base = "test.file"), '') - base.taint - dir.taint - assert_predicate(File.realpath(base, dir), :tainted?) - base.untaint - dir.taint - assert_predicate(File.realpath(base, dir), :tainted?) - base.taint - dir.untaint - assert_predicate(File.realpath(base, dir), :tainted?) - base.untaint - dir.untaint - assert_predicate(File.realpath(base, dir), :tainted?) - assert_predicate(Dir.chdir(dir) {File.realpath(base)}, :tainted?) - } - end - def test_realpath_special_symlink IO.pipe do |r, w| if File.pipe?(path = "/dev/fd/#{r.fileno}") diff --git a/test/ruby/test_file_exhaustive.rb b/test/ruby/test_file_exhaustive.rb index 4bb5479303..b96b727349 100644 --- a/test/ruby/test_file_exhaustive.rb +++ b/test/ruby/test_file_exhaustive.rb @@ -187,24 +187,6 @@ class TestFileExhaustive < Test::Unit::TestCase end end - def test_path_taint - [regular_file, utf8_file].each do |file| - file.untaint - assert_equal(false, File.open(file) {|f| f.path}.tainted?) - assert_equal(true, File.open(file.dup.taint) {|f| f.path}.tainted?) - o = Object.new - class << o; self; end.class_eval do - define_method(:to_path) { file } - end - assert_equal(false, File.open(o) {|f| f.path}.tainted?) - class << o; self; end.class_eval do - remove_method(:to_path) - define_method(:to_path) { file.dup.taint } - end - assert_equal(true, File.open(o) {|f| f.path}.tainted?) - end - end - def assert_integer(n) assert_kind_of(Integer, n) end @@ -1077,32 +1059,6 @@ class TestFileExhaustive < Test::Unit::TestCase assert_match(%r"\A#{DRIVE}/foo\z"i, File.expand_path('/foo')) end - def test_expand_path_returns_tainted_strings_or_not - assert_equal(true, File.expand_path('foo').tainted?) - assert_equal(true, File.expand_path('foo'.taint).tainted?) - assert_equal(true, File.expand_path('/foo'.taint).tainted?) - assert_equal(true, File.expand_path('foo', 'bar').tainted?) - assert_equal(true, File.expand_path('foo', '/bar'.taint).tainted?) - assert_equal(true, File.expand_path('foo'.taint, '/bar').tainted?) - assert_equal(true, File.expand_path('~').tainted?) if ENV["HOME"] - - if DRIVE - assert_equal(true, File.expand_path('/foo').tainted?) - assert_equal(false, File.expand_path('//foo').tainted?) - assert_equal(true, File.expand_path('C:/foo'.taint).tainted?) - assert_equal(false, File.expand_path('C:/foo').tainted?) - assert_equal(true, File.expand_path('foo', '/bar').tainted?) - assert_equal(true, File.expand_path('foo', 'C:/bar'.taint).tainted?) - assert_equal(true, File.expand_path('foo'.taint, 'C:/bar').tainted?) - assert_equal(false, File.expand_path('foo', 'C:/bar').tainted?) - assert_equal(false, File.expand_path('C:/foo/../bar').tainted?) - assert_equal(false, File.expand_path('foo', '//bar').tainted?) - else - assert_equal(false, File.expand_path('/foo').tainted?) - assert_equal(false, File.expand_path('foo', '/bar').tainted?) - end - end - def test_expand_path_converts_a_pathname_to_an_absolute_pathname_using_home_as_base old_home = ENV["HOME"] home = ENV["HOME"] = "#{DRIVE}/UserHome" diff --git a/test/ruby/test_hash.rb b/test/ruby/test_hash.rb index 8f6d782af4..ccc3355930 100644 --- a/test/ruby/test_hash.rb +++ b/test/ruby/test_hash.rb @@ -320,17 +320,6 @@ class TestHash < Test::Unit::TestCase assert_same "ABC".freeze, c.keys[0] end - def test_tainted_string_key - str = 'str'.taint - h = {} - h[str] = nil - key = h.keys.first - assert_predicate str, :tainted? - assert_not_predicate str, :frozen? - assert_predicate key, :tainted? - assert_predicate key, :frozen? - end - def test_EQUAL # '==' h1 = @cls[ "a" => 1, "c" => 2 ] h2 = @cls[ "a" => 1, "c" => 2, 7 => 35 ] @@ -353,18 +342,14 @@ class TestHash < Test::Unit::TestCase end def test_clone - for taint in [ false, true ] - for frozen in [ false, true ] - a = @h.clone - a.taint if taint - a.freeze if frozen - b = a.clone - - assert_equal(a, b) - assert_not_same(a, b) - assert_equal(a.frozen?, b.frozen?) - assert_equal(a.tainted?, b.tainted?) - end + for frozen in [ false, true ] + a = @h.clone + a.freeze if frozen + b = a.clone + + assert_equal(a, b) + assert_not_same(a, b) + assert_equal(a.frozen?, b.frozen?) end end @@ -451,18 +436,14 @@ class TestHash < Test::Unit::TestCase end def test_dup - for taint in [ false, true ] - for frozen in [ false, true ] - a = @h.dup - a.taint if taint - a.freeze if frozen - b = a.dup - - assert_equal(a, b) - assert_not_same(a, b) - assert_equal(false, b.frozen?) - assert_equal(a.tainted?, b.tainted?) - end + for frozen in [ false, true ] + a = @h.dup + a.freeze if frozen + b = a.dup + + assert_equal(a, b) + assert_not_same(a, b) + assert_equal(false, b.frozen?) end end @@ -712,10 +693,8 @@ class TestHash < Test::Unit::TestCase h.instance_variable_set(:@foo, :foo) h.default = 42 - h.taint h = EnvUtil.suppress_warning {h.reject {false}} assert_instance_of(Hash, h) - assert_not_predicate(h, :tainted?) assert_nil(h.default) assert_not_send([h, :instance_variable_defined?, :@foo]) end @@ -840,11 +819,6 @@ class TestHash < Test::Unit::TestCase assert_equal([3,4], a.delete([3,4])) assert_equal([5,6], a.delete([5,6])) assert_equal(0, a.length) - - h = @cls[ 1=>2, 3=>4, 5=>6 ] - h.taint - a = h.to_a - assert_equal(true, a.tainted?) end def test_to_hash @@ -1037,10 +1011,8 @@ class TestHash < Test::Unit::TestCase h.instance_variable_set(:@foo, :foo) h.default = 42 - h.taint h = h.select {true} assert_instance_of(Hash, h) - assert_not_predicate(h, :tainted?) assert_nil(h.default) assert_not_send([h, :instance_variable_defined?, :@foo]) end @@ -1083,10 +1055,8 @@ class TestHash < Test::Unit::TestCase h.instance_variable_set(:@foo, :foo) h.default = 42 - h.taint h = h.filter {true} assert_instance_of(Hash, h) - assert_not_predicate(h, :tainted?) assert_nil(h.default) assert_not_send([h, :instance_variable_defined?, :@foo]) end diff --git a/test/ruby/test_io.rb b/test/ruby/test_io.rb index cabcc652c1..f3b08154c8 100644 --- a/test/ruby/test_io.rb +++ b/test/ruby/test_io.rb @@ -2768,13 +2768,6 @@ class TestIO < Test::Unit::TestCase } end if /freebsd|linux/ =~ RUBY_PLATFORM and defined? File::NOFOLLOW - def test_tainted - make_tempfile {|t| - assert_predicate(File.read(t.path, 4), :tainted?, '[ruby-dev:38826]') - assert_predicate(File.open(t.path) {|f| f.read(4)}, :tainted?, '[ruby-dev:38826]') - } - end - def test_binmode_after_closed make_tempfile {|t| assert_raise(IOError) {t.binmode} diff --git a/test/ruby/test_m17n.rb b/test/ruby/test_m17n.rb index 44f3cc97a9..6c7d0e6bae 100644 --- a/test/ruby/test_m17n.rb +++ b/test/ruby/test_m17n.rb @@ -1582,8 +1582,6 @@ class TestM17N < Test::Unit::TestCase s = "\u3042" assert_equal(a("\xE3\x81\x82"), s.b) assert_equal(Encoding::ASCII_8BIT, s.b.encoding) - s.taint - assert_predicate(s.b, :tainted?) s = "abc".b assert_predicate(s.b, :ascii_only?) end @@ -1592,16 +1590,13 @@ class TestM17N < Test::Unit::TestCase str = "foo" assert_equal(str, str.scrub) assert_not_same(str, str.scrub) - assert_predicate(str.dup.taint.scrub, :tainted?) str = "\u3042\u3044" assert_equal(str, str.scrub) assert_not_same(str, str.scrub) - assert_predicate(str.dup.taint.scrub, :tainted?) str.force_encoding(Encoding::ISO_2022_JP) # dummy encoding assert_equal(str, str.scrub) assert_not_same(str, str.scrub) assert_nothing_raised(ArgumentError) {str.scrub(nil)} - assert_predicate(str.dup.taint.scrub, :tainted?) end def test_scrub_modification_inside_block @@ -1620,8 +1615,6 @@ class TestM17N < Test::Unit::TestCase def test_scrub_replace_default assert_equal("\uFFFD\uFFFD\uFFFD", u("\x80\x80\x80").scrub) assert_equal("\uFFFDA", u("\xF4\x80\x80A").scrub) - assert_predicate(u("\x80\x80\x80").taint.scrub, :tainted?) - assert_predicate(u("\xF4\x80\x80A").taint.scrub, :tainted?) # examples in Unicode 6.1.0 D93b assert_equal("\x41\uFFFD\uFFFD\x41\uFFFD\x41", @@ -1636,14 +1629,8 @@ class TestM17N < Test::Unit::TestCase def test_scrub_replace_argument assert_equal("foo", u("foo").scrub("\u3013")) - assert_predicate(u("foo").taint.scrub("\u3013"), :tainted?) - assert_not_predicate(u("foo").scrub("\u3013".taint), :tainted?) assert_equal("\u3042\u3044", u("\xE3\x81\x82\xE3\x81\x84").scrub("\u3013")) - assert_predicate(u("\xE3\x81\x82\xE3\x81\x84").taint.scrub("\u3013"), :tainted?) - assert_not_predicate(u("\xE3\x81\x82\xE3\x81\x84").scrub("\u3013".taint), :tainted?) assert_equal("\u3042\u3013", u("\xE3\x81\x82\xE3\x81").scrub("\u3013")) - assert_predicate(u("\xE3\x81\x82\xE3\x81").taint.scrub("\u3013"), :tainted?) - assert_predicate(u("\xE3\x81\x82\xE3\x81").scrub("\u3013".taint), :tainted?) assert_raise(Encoding::CompatibilityError){ u("\xE3\x81\x82\xE3\x81").scrub(e("\xA4\xA2")) } assert_raise(TypeError){ u("\xE3\x81\x82\xE3\x81").scrub(1) } assert_raise(ArgumentError){ u("\xE3\x81\x82\xE3\x81\x82\xE3\x81").scrub(u("\x81")) } @@ -1652,8 +1639,6 @@ class TestM17N < Test::Unit::TestCase def test_scrub_replace_block assert_equal("\u3042<e381>", u("\xE3\x81\x82\xE3\x81").scrub{|x|'<'+x.unpack('H*')[0]+'>'}) - assert_predicate(u("\xE3\x81\x82\xE3\x81").taint.scrub{|x|'<'+x.unpack('H*')[0]+'>'}, :tainted?) - assert_predicate(u("\xE3\x81\x82\xE3\x81").scrub{|x|('<'+x.unpack('H*')[0]+'>').taint}, :tainted?) assert_raise(Encoding::CompatibilityError){ u("\xE3\x81\x82\xE3\x81").scrub{e("\xA4\xA2")} } assert_raise(TypeError){ u("\xE3\x81\x82\xE3\x81").scrub{1} } assert_raise(ArgumentError){ u("\xE3\x81\x82\xE3\x81\x82\xE3\x81").scrub{u("\x81")} } diff --git a/test/ruby/test_marshal.rb b/test/ruby/test_marshal.rb index f6d84d181a..f300710d2c 100644 --- a/test/ruby/test_marshal.rb +++ b/test/ruby/test_marshal.rb @@ -189,57 +189,6 @@ class TestMarshal < Test::Unit::TestCase end end - def test_taint - x = Object.new - x.taint - s = Marshal.dump(x) - assert_equal(true, s.tainted?) - y = Marshal.load(s) - assert_equal(true, y.tainted?) - end - - def test_taint_each_object - x = Object.new - obj = [[x]] - - # clean object causes crean stream - assert_equal(false, obj.tainted?) - assert_equal(false, obj.first.tainted?) - assert_equal(false, obj.first.first.tainted?) - s = Marshal.dump(obj) - assert_equal(false, s.tainted?) - - # tainted object causes tainted stream - x.taint - assert_equal(false, obj.tainted?) - assert_equal(false, obj.first.tainted?) - assert_equal(true, obj.first.first.tainted?) - t = Marshal.dump(obj) - assert_equal(true, t.tainted?) - - # clean stream causes clean objects - assert_equal(false, s.tainted?) - y = Marshal.load(s) - assert_equal(false, y.tainted?) - assert_equal(false, y.first.tainted?) - assert_equal(false, y.first.first.tainted?) - - # tainted stream causes tainted objects - assert_equal(true, t.tainted?) - y = Marshal.load(t) - assert_equal(true, y.tainted?) - assert_equal(true, y.first.tainted?) - assert_equal(true, y.first.first.tainted?) - - # same tests by different senario - s.taint - assert_equal(true, s.tainted?) - y = Marshal.load(s) - assert_equal(true, y.tainted?) - assert_equal(true, y.first.tainted?) - assert_equal(true, y.first.first.tainted?) - end - def test_symbol2 [:ruby, :"\u{7d05}\u{7389}"].each do |sym| assert_equal(sym, Marshal.load(Marshal.dump(sym)), '[ruby-core:24788]') @@ -499,16 +448,6 @@ class TestMarshal < Test::Unit::TestCase module TestModule end - def test_marshal_load_should_not_taint_classes - bug7325 = '[ruby-core:49198]' - for c in [TestClass, TestModule] - assert_not_predicate(c, :tainted?) - c2 = Marshal.load(Marshal.dump(c).taint) - assert_same(c, c2) - assert_not_predicate(c, :tainted?, bug7325) - end - end - class Bug7627 < Struct.new(:bar) attr_accessor :foo @@ -620,15 +559,6 @@ class TestMarshal < Test::Unit::TestCase assert_equal(Marshal.dump(bare), Marshal.dump(packed)) end - def test_untainted_numeric - bug8945 = '[ruby-core:57346] [Bug #8945] Numerics never be tainted' - b = RbConfig::LIMITS['FIXNUM_MAX'] + 1 - tainted = [0, 1.0, 1.72723e-77, b].select do |x| - Marshal.load(Marshal.dump(x).taint).tainted? - end - assert_empty(tainted.map {|x| [x, x.class]}, bug8945) - end - class Bug9523 attr_reader :cc def marshal_dump diff --git a/test/ruby/test_method.rb b/test/ruby/test_method.rb index afab7eb900..3942e047e8 100644 --- a/test/ruby/test_method.rb +++ b/test/ruby/test_method.rb @@ -456,9 +456,6 @@ class TestMethod < Test::Unit::TestCase c3.class_eval { alias bar foo } m3 = c3.new.method(:bar) assert_equal("#<Method: #{c3.inspect}(#{c.inspect})#bar(foo) #{__FILE__}:#{line_no}>", m3.inspect, bug7806) - - m.taint - assert_predicate(m.inspect, :tainted?, "inspect result should be infected") end def test_callee_top_level diff --git a/test/ruby/test_object.rb b/test/ruby/test_object.rb index 013b3f01f5..add5b9fb15 100644 --- a/test/ruby/test_object.rb +++ b/test/ruby/test_object.rb @@ -96,17 +96,6 @@ class TestObject < Test::Unit::TestCase assert_raise(TypeError) { 1.kind_of?(1) } end - def test_taint_frozen_obj - o = Object.new - o.freeze - assert_raise(FrozenError) { o.taint } - - o = Object.new - o.taint - o.freeze - assert_raise(FrozenError) { o.untaint } - end - def test_freeze_immediate assert_equal(true, 1.frozen?) 1.freeze @@ -794,36 +783,7 @@ class TestObject < Test::Unit::TestCase end end - def test_untrusted - verbose = $VERBOSE - $VERBOSE = false - begin - obj = Object.new - assert_equal(false, obj.untrusted?) - assert_equal(false, obj.tainted?) - obj.untrust - assert_equal(true, obj.untrusted?) - assert_equal(true, obj.tainted?) - obj.trust - assert_equal(false, obj.untrusted?) - assert_equal(false, obj.tainted?) - obj.taint - assert_equal(true, obj.untrusted?) - assert_equal(true, obj.tainted?) - obj.untaint - assert_equal(false, obj.untrusted?) - assert_equal(false, obj.tainted?) - ensure - $VERBOSE = verbose - end - end - def test_to_s - x = Object.new - x.taint - s = x.to_s - assert_equal(true, s.tainted?) - x = eval(<<-EOS) class ToS\u{3042} new.to_s @@ -832,14 +792,10 @@ class TestObject < Test::Unit::TestCase assert_match(/\bToS\u{3042}:/, x) name = "X".freeze - x = Object.new.taint + x = Object.new class<<x;self;end.class_eval {define_method(:to_s) {name}} assert_same(name, x.to_s) - assert_not_predicate(name, :tainted?) - assert_raise(FrozenError) {name.taint} assert_equal("X", [x].join("")) - assert_not_predicate(name, :tainted?) - assert_not_predicate(eval('"X".freeze'), :tainted?) end def test_inspect @@ -953,7 +909,7 @@ class TestObject < Test::Unit::TestCase assert_nothing_raised("copy") {a.instance_eval {initialize_copy(b)}} c = a.dup.freeze assert_raise(FrozenError, "frozen") {c.instance_eval {initialize_copy(b)}} - d = a.dup.trust + d = a.dup [a, b, c, d] end diff --git a/test/ruby/test_pack.rb b/test/ruby/test_pack.rb index 658208d9df..60edd00186 100644 --- a/test/ruby/test_pack.rb +++ b/test/ruby/test_pack.rb @@ -869,20 +869,4 @@ EXPECTED assert_equal "hogefuga", "aG9nZWZ1Z2E=".unpack1("m") assert_equal "01000001", "A".unpack1("B*") end - - def test_pack_infection - tainted_array_string = ["123456"] - tainted_array_string.first.taint - ['a', 'A', 'Z', 'B', 'b', 'H', 'h', 'u', 'M', 'm', 'P', 'p'].each do |f| - assert_predicate(tainted_array_string.pack(f), :tainted?) - end - end - - def test_unpack_infection - tainted_string = "123456" - tainted_string.taint - ['a', 'A', 'Z', 'B', 'b', 'H', 'h', 'u', 'M', 'm'].each do |f| - assert_predicate(tainted_string.unpack(f).first, :tainted?) - end - end end diff --git a/test/ruby/test_proc.rb b/test/ruby/test_proc.rb index 0e0b5c7b8b..ea3fe823f0 100644 --- a/test/ruby/test_proc.rb +++ b/test/ruby/test_proc.rb @@ -1158,9 +1158,6 @@ class TestProc < Test::Unit::TestCase assert_match(/^#<Proc:0x\h+ #{ Regexp.quote(__FILE__) }:\d+>$/, proc {}.to_s) assert_match(/^#<Proc:0x\h+ #{ Regexp.quote(__FILE__) }:\d+ \(lambda\)>$/, lambda {}.to_s) assert_match(/^#<Proc:0x\h+ \(lambda\)>$/, method(:p).to_proc.to_s) - x = proc {} - x.taint - assert_predicate(x.to_s, :tainted?) name = "Proc\u{1f37b}" assert_include(EnvUtil.labeled_class(name, Proc).new {}.to_s, name) end diff --git a/test/ruby/test_range.rb b/test/ruby/test_range.rb index 0dee88e7f9..4df14539a9 100644 --- a/test/ruby/test_range.rb +++ b/test/ruby/test_range.rb @@ -499,11 +499,6 @@ class TestRange < Test::Unit::TestCase assert_equal("0...1", (0...1).to_s) assert_equal("0..", (0..nil).to_s) assert_equal("0...", (0...nil).to_s) - - bug11767 = '[ruby-core:71811] [Bug #11767]' - assert_predicate(("0".taint.."1").to_s, :tainted?, bug11767) - assert_predicate(("0".."1".taint).to_s, :tainted?, bug11767) - assert_predicate(("0".."1").taint.to_s, :tainted?, bug11767) end def test_inspect @@ -515,11 +510,6 @@ class TestRange < Test::Unit::TestCase assert_equal("...1", (nil...1).inspect) assert_equal("nil..nil", (nil..nil).inspect) assert_equal("nil...nil", (nil...nil).inspect) - - bug11767 = '[ruby-core:71811] [Bug #11767]' - assert_predicate(("0".taint.."1").inspect, :tainted?, bug11767) - assert_predicate(("0".."1".taint).inspect, :tainted?, bug11767) - assert_predicate(("0".."1").taint.inspect, :tainted?, bug11767) end def test_eqq diff --git a/test/ruby/test_refinement.rb b/test/ruby/test_refinement.rb index 34451de482..9d8bb92648 100644 --- a/test/ruby/test_refinement.rb +++ b/test/ruby/test_refinement.rb @@ -2064,7 +2064,6 @@ class TestRefinement < Test::Unit::TestCase def test_tostring assert_equal("ok", ToString.new.string) - assert_predicate(ToString.new.taint.string, :tainted?) end class ToSymbol diff --git a/test/ruby/test_require.rb b/test/ruby/test_require.rb index e21ed88e47..e310ac7c70 100644 --- a/test/ruby/test_require.rb +++ b/test/ruby/test_require.rb @@ -379,31 +379,6 @@ class TestRequire < Test::Unit::TestCase end end - def test_tainted_loadpath - Tempfile.create(["test_ruby_test_require", ".rb"]) {|t| - abs_dir, file = File.split(t.path) - abs_dir = File.expand_path(abs_dir).untaint - - assert_separately([], <<-INPUT) - abs_dir = "#{ abs_dir }" - $: << abs_dir - assert_nothing_raised {require "#{ file }"} - INPUT - - assert_separately([], <<-INPUT) - abs_dir = "#{ abs_dir }" - $: << abs_dir.taint - assert_nothing_raised {require "#{ file }"} - INPUT - - assert_separately([], <<-INPUT) - abs_dir = "#{ abs_dir }" - $: << abs_dir << 'elsewhere'.taint - assert_nothing_raised {require "#{ file }"} - INPUT - } - end - def test_relative load_path = $:.dup $:.delete(".") diff --git a/test/ruby/test_rubyoptions.rb b/test/ruby/test_rubyoptions.rb index 27a9434a5c..10d54550c1 100644 --- a/test/ruby/test_rubyoptions.rb +++ b/test/ruby/test_rubyoptions.rb @@ -1043,13 +1043,6 @@ class TestRubyOptions < Test::Unit::TestCase assert_in_out_err([IO::NULL], success: true) end - def test_argv_tainted - assert_separately(%w[- arg], "#{<<~"begin;"}\n#{<<~'end;'}") - begin; - assert_predicate(ARGV[0], :tainted?, '[ruby-dev:50596] [Bug #14941]') - end; - end - private def mjit_force_enabled? diff --git a/test/ruby/test_signal.rb b/test/ruby/test_signal.rb index 48cb60cb77..a62537d59d 100644 --- a/test/ruby/test_signal.rb +++ b/test/ruby/test_signal.rb @@ -137,11 +137,6 @@ class TestSignal < Test::Unit::TestCase assert_raise(ArgumentError) { Signal.trap } - assert_raise(SecurityError) do - s = proc {}.taint - Signal.trap(:INT, s) - end - # FIXME! Signal.trap(:INT, nil) Signal.trap(:INT, "") diff --git a/test/ruby/test_string.rb b/test/ruby/test_string.rb index 41d4871379..a86e26c774 100644 --- a/test/ruby/test_string.rb +++ b/test/ruby/test_string.rb @@ -607,18 +607,14 @@ CODE end def test_clone - for taint in [ false, true ] - for frozen in [ false, true ] - a = S("Cool") - a.taint if taint - a.freeze if frozen - b = a.clone - - assert_equal(a, b) - assert_not_same(a, b) - assert_equal(a.frozen?, b.frozen?) - assert_equal(a.tainted?, b.tainted?) - end + for frozen in [ false, true ] + a = S("Cool") + a.freeze if frozen + b = a.clone + + assert_equal(a, b) + assert_not_same(a, b) + assert_equal(a.frozen?, b.frozen?) end assert_equal("", File.read(IO::NULL).clone, '[ruby-dev:32819] reported by Kazuhiro NISHIYAMA') @@ -851,18 +847,14 @@ CODE end def test_dup - for taint in [ false, true ] - for frozen in [ false, true ] - a = S("hello") - a.taint if taint - a.freeze if frozen - b = a.dup - - assert_equal(a, b) - assert_not_same(a, b) - assert_not_predicate(b, :frozen?) - assert_equal(a.tainted?, b.tainted?) - end + for frozen in [ false, true ] + a = S("hello") + a.freeze if frozen + b = a.dup + + assert_equal(a, b) + assert_not_same(a, b) + assert_not_predicate(b, :frozen?) end end @@ -1005,7 +997,6 @@ CODE ].each do |g| assert_equal [g], g.each_grapheme_cluster.to_a assert_equal 1, g.each_grapheme_cluster.size - assert_predicate g.dup.taint.each_grapheme_cluster.to_a[0], :tainted? end [ @@ -1015,9 +1006,6 @@ CODE ].each do |str, grapheme_clusters| assert_equal grapheme_clusters, str.each_grapheme_cluster.to_a assert_equal grapheme_clusters.size, str.each_grapheme_cluster.size - str.dup.taint.each_grapheme_cluster do |g| - assert_predicate g, :tainted? - end end s = ("x"+"\u{10ABCD}"*250000) @@ -1039,7 +1027,6 @@ CODE ].product([Encoding::UTF_8, *WIDE_ENCODINGS]) do |g, enc| g = g.encode(enc) assert_equal [g], g.grapheme_clusters - assert_predicate g.taint.grapheme_clusters[0], :tainted? end [ @@ -1057,14 +1044,13 @@ CODE assert_equal ["A", "B", "C"], "ABC".grapheme_clusters {} } else - s = "ABC".b.taint + s = "ABC".b res = [] assert_same s, s.grapheme_clusters {|x| res << x } assert_equal(3, res.size) assert_equal("A", res[0]) assert_equal("B", res[1]) assert_equal("C", res[2]) - res.each {|g| assert_predicate(g, :tainted?)} end end @@ -1213,10 +1199,6 @@ CODE S("hello").gsub(/(hell)(.)/) { |s| $1.upcase + S('-') + $2 }) assert_equal(S("<>h<>e<>l<>l<>o<>"), S("hello").gsub(S(''), S('<\0>'))) - a = S("hello") - a.taint - assert_predicate(a.gsub(/./, S('X')), :tainted?) - assert_equal("z", "abc".gsub(/./, "a" => "z"), "moved from btest/knownbug") assert_raise(ArgumentError) { "foo".gsub } @@ -1261,11 +1243,6 @@ CODE a.gsub!(/(hell)(.)/) { |s| $1.upcase + S('-') + $2 } assert_equal(S("HELL-o"), a) - r = S('X') - r.taint - a.gsub!(/./, r) - assert_predicate(a, :tainted?) - a = S("hello") assert_nil(a.sub!(S('X'), S('Y'))) end @@ -1457,10 +1434,8 @@ CODE assert_equal(S("foobar"), a.replace(S("foobar"))) a = S("foo") - a.taint b = a.replace(S("xyz")) assert_equal(S("xyz"), b) - assert_predicate(b, :tainted?) s = "foo" * 100 s2 = ("bar" * 100).dup @@ -1555,12 +1530,6 @@ CODE a.scan(/(...)/) { |w| res << w } assert_equal([[S("cru")], [S("el ")], [S("wor")]],res) - a = S("hello") - a.taint - res = [] - a.scan(/./) { |w| res << w } - assert_predicate(res[0], :tainted?, '[ruby-core:33338] #4087') - /h/ =~ a a.scan(/x/) assert_nil($~) @@ -1569,8 +1538,6 @@ CODE a.scan('x') assert_nil($~) - assert_equal(3, S("hello hello hello").scan("hello".taint).count(&:tainted?)) - assert_equal(%w[1 2 3], S("a1 a2 a3").scan(/a\K./)) end @@ -1954,11 +1921,6 @@ CODE assert_equal(S("a\\&aba"), S("ababa").sub(/b/, '\\\\&')) assert_equal(S("a\\baba"), S("ababa").sub(/b/, '\\\\\&')) - a = S("hello") - a.taint - x = a.sub(/./, S('X')) - assert_predicate(x, :tainted?) - o = Object.new def o.to_str; "bar"; end assert_equal("fooBARbaz", "foobarbaz".sub(o, "BAR")) @@ -2006,11 +1968,6 @@ CODE a=S("hello") assert_nil(a.sub!(/X/, S('Y'))) - r = S('X') - r.taint - a.sub!(/./, r) - assert_predicate(a, :tainted?) - bug16105 = '[Bug #16105] heap-use-after-free' a = S("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345678") b = a.dup @@ -3201,10 +3158,8 @@ CODE assert_equal(1, str.instance_variable_get(:@iv)) str = @cls.new("foo") - str.taint assert_instance_of(@cls, -str) assert_equal(false, str.frozen?) - assert_predicate(str, :tainted?) end def test_ord diff --git a/test/ruby/test_symbol.rb b/test/ruby/test_symbol.rb index d657f1aae6..c47cadf4bb 100644 --- a/test/ruby/test_symbol.rb +++ b/test/ruby/test_symbol.rb @@ -538,14 +538,6 @@ class TestSymbol < Test::Unit::TestCase end; end - def test_not_freeze - bug11721 = '[ruby-core:71611] [Bug #11721]' - str = "\u{1f363}".taint - assert_not_predicate(str, :frozen?) - assert_equal str, str.to_sym.to_s - assert_not_predicate(str, :frozen?, bug11721) - end - def test_hash_nondeterministic ruby = EnvUtil.rubybin assert_not_equal :foo.hash, `#{ruby} -e 'puts :foo.hash'`.to_i, diff --git a/test/ruby/test_trace.rb b/test/ruby/test_trace.rb index 77be94e9be..5842f11aee 100644 --- a/test/ruby/test_trace.rb +++ b/test/ruby/test_trace.rb @@ -20,17 +20,6 @@ class TestTrace < Test::Unit::TestCase untrace_var :$x end - def test_trace_tainted_proc - $x = 1234 - s = proc { $y = :foo } - trace_var :$x, s - s.taint - $x = 42 - assert_equal(:foo, $y) - ensure - untrace_var :$x - end - def test_trace_proc_that_raises_exception $x = 1234 trace_var :$x, proc { raise } diff --git a/test/strscan/test_stringscanner.rb b/test/strscan/test_stringscanner.rb index 5e798028b7..4b001b317e 100644 --- a/test/strscan/test_stringscanner.rb +++ b/test/strscan/test_stringscanner.rb @@ -16,20 +16,12 @@ class TestStringScanner < Test::Unit::TestCase s = create_string_scanner('test string') assert_instance_of StringScanner, s assert_equal false, s.eos? - assert_equal false, s.tainted? str = 'test string'.dup - str.taint s = create_string_scanner(str, false) assert_instance_of StringScanner, s assert_equal false, s.eos? assert_same str, s.string - assert_equal true, s.string.tainted? - - str = 'test string'.dup - str.taint - s = create_string_scanner(str) - assert_equal true, s.string.tainted? end UNINIT_ERROR = ArgumentError @@ -101,14 +93,12 @@ class TestStringScanner < Test::Unit::TestCase def test_inspect str = 'test string'.dup - str.taint s = create_string_scanner(str, false) assert_instance_of String, s.inspect assert_equal s.inspect, s.inspect assert_equal '#<StringScanner 0/11 @ "test ...">', s.inspect.sub(/StringScanner_C/, 'StringScanner') s.get_byte assert_equal '#<StringScanner 1/11 "t" @ "est s...">', s.inspect.sub(/StringScanner_C/, 'StringScanner') - assert_equal true, s.inspect.tainted? s = create_string_scanner("\n") assert_equal '#<StringScanner 0/1 @ "\n">', s.inspect @@ -233,40 +223,33 @@ class TestStringScanner < Test::Unit::TestCase s = create_string_scanner('stra strb strc', true) tmp = s.scan(/\w+/) assert_equal 'stra', tmp - assert_equal false, tmp.tainted? tmp = s.scan(/\s+/) assert_equal ' ', tmp - assert_equal false, tmp.tainted? assert_equal 'strb', s.scan(/\w+/) assert_equal ' ', s.scan(/\s+/) tmp = s.scan(/\w+/) assert_equal 'strc', tmp - assert_equal false, tmp.tainted? assert_nil s.scan(/\w+/) assert_nil s.scan(/\w+/) str = 'stra strb strc'.dup - str.taint s = create_string_scanner(str, false) tmp = s.scan(/\w+/) assert_equal 'stra', tmp - assert_equal true, tmp.tainted? tmp = s.scan(/\s+/) assert_equal ' ', tmp - assert_equal true, tmp.tainted? assert_equal 'strb', s.scan(/\w+/) assert_equal ' ', s.scan(/\s+/) tmp = s.scan(/\w+/) assert_equal 'strc', tmp - assert_equal true, tmp.tainted? assert_nil s.scan(/\w+/) assert_nil s.scan(/\w+/) @@ -291,15 +274,12 @@ class TestStringScanner < Test::Unit::TestCase assert_equal 'str', s.scan('str') assert_equal 'str', s[0] assert_equal 3, s.pos - assert_equal false, s.tainted? assert_equal 'a ', s.scan('a ') str = 'stra strb strc'.dup - str.taint s = create_string_scanner(str, false) matched = s.scan('str') assert_equal 'str', matched - assert_equal true, matched.tainted? end def test_skip @@ -346,14 +326,6 @@ class TestStringScanner < Test::Unit::TestCase assert_equal 'e', s.getch assert_nil s.getch - str = 'abc'.dup - str.taint - s = create_string_scanner(str) - assert_equal true, s.getch.tainted? - assert_equal true, s.getch.tainted? - assert_equal true, s.getch.tainted? - assert_nil s.getch - s = create_string_scanner("\244\242".dup.force_encoding("euc-jp")) assert_equal "\244\242".dup.force_encoding("euc-jp"), s.getch assert_nil s.getch @@ -374,14 +346,6 @@ class TestStringScanner < Test::Unit::TestCase assert_nil s.get_byte assert_nil s.get_byte - str = 'abc'.dup - str.taint - s = create_string_scanner(str) - assert_equal true, s.get_byte.tainted? - assert_equal true, s.get_byte.tainted? - assert_equal true, s.get_byte.tainted? - assert_nil s.get_byte - s = create_string_scanner("\244\242".dup.force_encoding("euc-jp")) assert_equal "\244".dup.force_encoding("euc-jp"), s.get_byte assert_equal "\242".dup.force_encoding("euc-jp"), s.get_byte @@ -397,7 +361,6 @@ class TestStringScanner < Test::Unit::TestCase s = create_string_scanner('stra strb strc') s.scan(/\w+/) assert_equal 'stra', s.matched - assert_equal false, s.matched.tainted? s.scan(/\s+/) assert_equal ' ', s.matched s.scan('st') @@ -416,18 +379,9 @@ class TestStringScanner < Test::Unit::TestCase s = create_string_scanner('stra strb strc') s.getch assert_equal 's', s.matched - assert_equal false, s.matched.tainted? s.get_byte assert_equal 't', s.matched assert_equal 't', s.matched - assert_equal false, s.matched.tainted? - - str = 'test'.dup - str.taint - s = create_string_scanner(str) - s.scan(/\w+/) - assert_equal true, s.matched.tainted? - assert_equal true, s.matched.tainted? end def test_AREF @@ -441,9 +395,6 @@ class TestStringScanner < Test::Unit::TestCase assert_raise(IndexError) { s[:c] } assert_raise(IndexError) { s['c'] } - assert_equal false, s[-1].tainted? - assert_equal false, s[0].tainted? - s.skip(/\s+/) assert_nil s[-2] assert_equal ' ', s[-1] @@ -486,16 +437,6 @@ class TestStringScanner < Test::Unit::TestCase s.getch assert_equal "\244\242".dup.force_encoding("euc-jp"), s[0] - str = 'test'.dup - str.taint - s = create_string_scanner(str) - s.scan(/(t)(e)(s)(t)/) - assert_equal true, s[0].tainted? - assert_equal true, s[1].tainted? - assert_equal true, s[2].tainted? - assert_equal true, s[3].tainted? - assert_equal true, s[4].tainted? - s = create_string_scanner("foo bar baz") s.scan(/(?<a>\w+) (?<b>\w+) (\w+)/) assert_equal 'foo', s[1] @@ -514,10 +455,8 @@ class TestStringScanner < Test::Unit::TestCase s = create_string_scanner('a b c d e') s.scan(/\w/) assert_equal '', s.pre_match - assert_equal false, s.pre_match.tainted? s.skip(/\s/) assert_equal 'a', s.pre_match - assert_equal false, s.pre_match.tainted? s.scan('b') assert_equal 'a ', s.pre_match s.scan_until(/c/) @@ -530,16 +469,6 @@ class TestStringScanner < Test::Unit::TestCase assert_equal 'a b c d', s.pre_match s.scan(/never match/) assert_nil s.pre_match - - str = 'test string'.dup - str.taint - s = create_string_scanner(str) - s.scan(/\w+/) - assert_equal true, s.pre_match.tainted? - s.scan(/\s+/) - assert_equal true, s.pre_match.tainted? - s.scan(/\w+/) - assert_equal true, s.pre_match.tainted? end def test_post_match @@ -564,16 +493,6 @@ class TestStringScanner < Test::Unit::TestCase assert_equal '', s.post_match s.scan(/./) assert_nil s.post_match - - str = 'test string'.dup - str.taint - s = create_string_scanner(str) - s.scan(/\w+/) - assert_equal true, s.post_match.tainted? - s.scan(/\s+/) - assert_equal true, s.post_match.tainted? - s.scan(/\w+/) - assert_equal true, s.post_match.tainted? end def test_terminate diff --git a/test/test_set.rb b/test/test_set.rb index b20920e63e..b0f669ce86 100644 --- a/test/test_set.rb +++ b/test/test_set.rb @@ -696,15 +696,6 @@ class TC_Set < Test::Unit::TestCase assert_equal(set, ret.flatten) end - def test_taintness - orig = set = Set[1,2,3] - assert_equal false, set.tainted? - assert_same orig, set.taint - assert_equal true, set.tainted? - assert_same orig, set.untaint - assert_equal false, set.tainted? - end - def test_freeze orig = set = Set[1,2,3] assert_equal false, set.frozen? |