From 805c20a8e59315f15dbb22ac1518de6a27385039 Mon Sep 17 00:00:00 2001
From: akr <akr@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>
Date: Mon, 5 Oct 2015 13:27:48 +0000
Subject: * lib/pp.rb: Use frozen_string_literal: true.

* lib/prettyprint.rb: Ditto.

* lib/resolv.rb: Ditto.

* lib/tmpdir.rb: Ditto.

* test/test_pp.rb: Ditto.

* test/test_prettyprint.rb: Ditto.

* tool/transcode-tblgen.rb: Ditto.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@52042 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
---
 test/test_pp.rb | 50 ++++++++++++++++++++++++++------------------------
 1 file changed, 26 insertions(+), 24 deletions(-)

(limited to 'test/test_pp.rb')

diff --git a/test/test_pp.rb b/test/test_pp.rb
index 813daf0446..69594c0aef 100644
--- a/test/test_pp.rb
+++ b/test/test_pp.rb
@@ -1,3 +1,5 @@
+# -*- frozen_string_literal: true -*-
+
 require 'pp'
 require 'delegate'
 require 'test/unit'
@@ -6,24 +8,24 @@ module PPTestModule
 
 class PPTest < Test::Unit::TestCase
   def test_list0123_12
-    assert_equal("[0, 1, 2, 3]\n", PP.pp([0,1,2,3], '', 12))
+    assert_equal("[0, 1, 2, 3]\n", PP.pp([0,1,2,3], ''.dup, 12))
   end
 
   def test_list0123_11
-    assert_equal("[0,\n 1,\n 2,\n 3]\n", PP.pp([0,1,2,3], '', 11))
+    assert_equal("[0,\n 1,\n 2,\n 3]\n", PP.pp([0,1,2,3], ''.dup, 11))
   end
 
   OverriddenStruct = Struct.new("OverriddenStruct", :members, :class)
   def test_struct_override_members # [ruby-core:7865]
     a = OverriddenStruct.new(1,2)
-    assert_equal("#<struct Struct::OverriddenStruct members=1, class=2>\n", PP.pp(a, ''))
+    assert_equal("#<struct Struct::OverriddenStruct members=1, class=2>\n", PP.pp(a, ''.dup))
   end
 
   def test_redefined_method
-    o = ""
+    o = "".dup
     def o.method
     end
-    assert_equal(%(""\n), PP.pp(o, ""))
+    assert_equal(%(""\n), PP.pp(o, "".dup))
   end
 end
 
@@ -76,17 +78,17 @@ end
 class PPInspectTest < Test::Unit::TestCase
   def test_hasinspect
     a = HasInspect.new(1)
-    assert_equal("<inspect:1>\n", PP.pp(a, ''))
+    assert_equal("<inspect:1>\n", PP.pp(a, ''.dup))
   end
 
   def test_hasprettyprint
     a = HasPrettyPrint.new(1)
-    assert_equal("<pretty_print:1>\n", PP.pp(a, ''))
+    assert_equal("<pretty_print:1>\n", PP.pp(a, ''.dup))
   end
 
   def test_hasboth
     a = HasBoth.new(1)
-    assert_equal("<pretty_print:1>\n", PP.pp(a, ''))
+    assert_equal("<pretty_print:1>\n", PP.pp(a, ''.dup))
   end
 
   def test_pretty_print_inspect
@@ -98,21 +100,21 @@ class PPInspectTest < Test::Unit::TestCase
 
   def test_proc
     a = proc {1}
-    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''.dup))
   end
 
   def test_to_s_with_iv
     a = Object.new
     def a.to_s() "aaa" end
     a.instance_eval { @a = nil }
-    result = PP.pp(a, '')
+    result = PP.pp(a, ''.dup)
     assert_equal("#{a.inspect}\n", result)
   end
 
   def test_to_s_without_iv
     a = Object.new
     def a.to_s() "aaa" end
-    result = PP.pp(a, '')
+    result = PP.pp(a, ''.dup)
     assert_equal("#{a.inspect}\n", result)
   end
 end
@@ -121,48 +123,48 @@ class PPCycleTest < Test::Unit::TestCase
   def test_array
     a = []
     a << a
-    assert_equal("[[...]]\n", PP.pp(a, ''))
-    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+    assert_equal("[[...]]\n", PP.pp(a, ''.dup))
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''.dup))
   end
 
   def test_hash
     a = {}
     a[0] = a
-    assert_equal("{0=>{...}}\n", PP.pp(a, ''))
-    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+    assert_equal("{0=>{...}}\n", PP.pp(a, ''.dup))
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''.dup))
   end
 
   S = Struct.new("S", :a, :b)
   def test_struct
     a = S.new(1,2)
     a.b = a
-    assert_equal("#<struct Struct::S a=1, b=#<struct Struct::S:...>>\n", PP.pp(a, ''))
-    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+    assert_equal("#<struct Struct::S a=1, b=#<struct Struct::S:...>>\n", PP.pp(a, ''.dup))
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''.dup))
   end
 
   def test_object
     a = Object.new
     a.instance_eval {@a = a}
-    assert_equal(a.inspect + "\n", PP.pp(a, ''))
+    assert_equal(a.inspect + "\n", PP.pp(a, ''.dup))
   end
 
   def test_anonymous
     a = Class.new.new
-    assert_equal(a.inspect + "\n", PP.pp(a, ''))
+    assert_equal(a.inspect + "\n", PP.pp(a, ''.dup))
   end
 
   def test_withinspect
     a = []
     a << HasInspect.new(a)
-    assert_equal("[<inspect:[...]>]\n", PP.pp(a, ''))
-    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+    assert_equal("[<inspect:[...]>]\n", PP.pp(a, ''.dup))
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''.dup))
   end
 
   def test_share_nil
     begin
       PP.sharing_detection = true
       a = [nil, nil]
-      assert_equal("[nil, nil]\n", PP.pp(a, ''))
+      assert_equal("[nil, nil]\n", PP.pp(a, ''.dup))
     ensure
       PP.sharing_detection = false
     end
@@ -171,8 +173,8 @@ end
 
 class PPSingleLineTest < Test::Unit::TestCase
   def test_hash
-    assert_equal("{1=>1}", PP.singleline_pp({ 1 => 1}, '')) # [ruby-core:02699]
-    assert_equal("[1#{', 1'*99}]", PP.singleline_pp([1]*100, ''))
+    assert_equal("{1=>1}", PP.singleline_pp({ 1 => 1}, ''.dup)) # [ruby-core:02699]
+    assert_equal("[1#{', 1'*99}]", PP.singleline_pp([1]*100, ''.dup))
   end
 end
 
-- 
cgit v1.2.3