applies new string literal convention in actionpack/test

The current code base is not uniform. After some discussion,
we have chosen to go with double quotes by default.

2 files changed, 46 insertions, 46 deletions

diff --git a/actionpack/test/journey/nfa/simulator_test.rb b/actionpack/test/journey/nfa/simulator_test.rb
index 673a491fe5..117208c4a4 100644
--- a/actionpack/test/journey/nfa/simulator_test.rb
+++ b/actionpack/test/journey/nfa/simulator_test.rb
@@ -1,47 +1,47 @@
-require 'abstract_unit'
+require "abstract_unit"
 
 module ActionDispatch
   module Journey
     module NFA
       class TestSimulator < ActiveSupport::TestCase
         def test_simulate_simple
-          sim = simulator_for ['/foo']
-          assert_match sim, '/foo'
+          sim = simulator_for ["/foo"]
+          assert_match sim, "/foo"
         end
 
         def test_simulate_simple_no_match
-          sim = simulator_for ['/foo']
-          assert_no_match sim, 'foo'
+          sim = simulator_for ["/foo"]
+          assert_no_match sim, "foo"
         end
 
         def test_simulate_simple_no_match_too_long
-          sim = simulator_for ['/foo']
-          assert_no_match sim, '/foo/bar'
+          sim = simulator_for ["/foo"]
+          assert_no_match sim, "/foo/bar"
         end
 
         def test_simulate_simple_no_match_wrong_string
-          sim = simulator_for ['/foo']
-          assert_no_match sim, '/bar'
+          sim = simulator_for ["/foo"]
+          assert_no_match sim, "/bar"
         end
 
         def test_simulate_regex
-          sim = simulator_for ['/:foo/bar']
-          assert_match sim, '/bar/bar'
-          assert_match sim, '/foo/bar'
+          sim = simulator_for ["/:foo/bar"]
+          assert_match sim, "/bar/bar"
+          assert_match sim, "/foo/bar"
         end
 
         def test_simulate_or
-          sim = simulator_for ['/foo', '/bar']
-          assert_match sim, '/bar'
-          assert_match sim, '/foo'
-          assert_no_match sim, '/baz'
+          sim = simulator_for ["/foo", "/bar"]
+          assert_match sim, "/bar"
+          assert_match sim, "/foo"
+          assert_no_match sim, "/baz"
         end
 
         def test_simulate_optional
-          sim = simulator_for ['/foo(/bar)']
-          assert_match sim, '/foo'
-          assert_match sim, '/foo/bar'
-          assert_no_match sim, '/foo/'
+          sim = simulator_for ["/foo(/bar)"]
+          assert_match sim, "/foo"
+          assert_match sim, "/foo/bar"
+          assert_no_match sim, "/foo/"
         end
 
         def test_matchdata_has_memos
@@ -59,17 +59,17 @@ module ActionDispatch
 
           sim = Simulator.new builder.transition_table
 
-          md = sim.match '/foo'
+          md = sim.match "/foo"
           assert_equal [expected], md.memos
         end
 
         def test_matchdata_memos_on_merge
           parser = Journey::Parser.new
           routes = [
-            '/articles(.:format)',
-            '/articles/new(.:format)',
-            '/articles/:id/edit(.:format)',
-            '/articles/:id(.:format)',
+            "/articles(.:format)",
+            "/articles/new(.:format)",
+            "/articles/:id/edit(.:format)",
+            "/articles/:id(.:format)",
           ].map { |path|
             ast = parser.parse path
             ast.each { |n| n.memo = ast }
@@ -82,7 +82,7 @@ module ActionDispatch
 
           nfa   = Journey::NFA::Builder.new ast
           sim = Simulator.new nfa.transition_table
-          md = sim.match '/articles'
+          md = sim.match "/articles"
           assert_equal [asts.first], md.memos
         end
 
diff --git a/actionpack/test/journey/nfa/transition_table_test.rb b/actionpack/test/journey/nfa/transition_table_test.rb
index 1248082c03..81f9501688 100644
--- a/actionpack/test/journey/nfa/transition_table_test.rb
+++ b/actionpack/test/journey/nfa/transition_table_test.rb
@@ -1,4 +1,4 @@
-require 'abstract_unit'
+require "abstract_unit"
 
 module ActionDispatch
   module Journey
@@ -9,55 +9,55 @@ module ActionDispatch
         end
 
         def test_eclosure
-          table = tt '/'
+          table = tt "/"
           assert_equal [0], table.eclosure(0)
 
-          table = tt ':a|:b'
+          table = tt ":a|:b"
           assert_equal 3, table.eclosure(0).length
 
-          table = tt '(:a|:b)'
+          table = tt "(:a|:b)"
           assert_equal 5, table.eclosure(0).length
           assert_equal 5, table.eclosure([0]).length
         end
 
         def test_following_states_one
-          table = tt '/'
+          table = tt "/"
 
-          assert_equal [1], table.following_states(0, '/')
-          assert_equal [1], table.following_states([0], '/')
+          assert_equal [1], table.following_states(0, "/")
+          assert_equal [1], table.following_states([0], "/")
         end
 
         def test_following_states_group
-          table  = tt 'a|b'
+          table  = tt "a|b"
           states = table.eclosure 0
 
-          assert_equal 1, table.following_states(states, 'a').length
-          assert_equal 1, table.following_states(states, 'b').length
+          assert_equal 1, table.following_states(states, "a").length
+          assert_equal 1, table.following_states(states, "b").length
         end
 
         def test_following_states_multi
-          table  = tt 'a|a'
+          table  = tt "a|a"
           states = table.eclosure 0
 
-          assert_equal 2, table.following_states(states, 'a').length
-          assert_equal 0, table.following_states(states, 'b').length
+          assert_equal 2, table.following_states(states, "a").length
+          assert_equal 0, table.following_states(states, "b").length
         end
 
         def test_following_states_regexp
-          table  = tt 'a|:a'
+          table  = tt "a|:a"
           states = table.eclosure 0
 
-          assert_equal 1, table.following_states(states, 'a').length
+          assert_equal 1, table.following_states(states, "a").length
           assert_equal 1, table.following_states(states, /[^\.\/\?]+/).length
-          assert_equal 0, table.following_states(states, 'b').length
+          assert_equal 0, table.following_states(states, "b").length
         end
 
         def test_alphabet
-          table  = tt 'a|:a'
-          assert_equal [/[^\.\/\?]+/, 'a'], table.alphabet
+          table  = tt "a|:a"
+          assert_equal [/[^\.\/\?]+/, "a"], table.alphabet
 
-          table  = tt 'a|a'
-          assert_equal ['a'], table.alphabet
+          table  = tt "a|a"
+          assert_equal ["a"], table.alphabet
         end
 
         private