cucumber 0.8.7 → 0.9.0

data/lib/cucumber/wire_support/configuration.rb

@@ -1,3 +1,5 @@
+require 'yaml'
+
 module Cucumber
   module WireSupport
     class Configuration

data/lib/cucumber/wire_support/wire_language.rb

@@ -1,12 +1,5 @@
 require 'socket'
-begin
-  require 'json'
-rescue LoadError
-  STDERR.puts <<-EOM
-You must gem install #{defined?(JRUBY_VERSION) ? 'json_pure' : 'json'} before you can use the wire support.
-EOM
-  exit(1)
-end
+require 'json'
 require 'cucumber/wire_support/connection'
 require 'cucumber/wire_support/configuration'
 require 'cucumber/wire_support/wire_packet'

data/spec/cucumber/ast/background_spec.rb

@@ -8,8 +8,8 @@ module Cucumber
 
       before do
         extend(Cucumber::RbSupport::RbDsl)
-        @step_mother = Cucumber::StepMother.new
-        @rb = @step_mother.load_programming_language('rb')
+        @runtime = Cucumber::Runtime.new
+        @rb = @runtime.load_programming_language('rb')
 
         $x = $y = nil
         Before do
@@ -19,7 +19,7 @@ module Cucumber
           $y = $x * n.to_i
         end
 
-        @visitor = TreeWalker.new(@step_mother)
+        @visitor = TreeWalker.new(@runtime)
 
         @feature = mock('feature', :visit? => true).as_null_object
       end

data/spec/cucumber/ast/feature_spec.rb

@@ -7,7 +7,7 @@ module Cucumber
       include FeatureFactory
 
       it "should convert to sexp" do
-        step_mother = Cucumber::StepMother.new
+        step_mother = Cucumber::Runtime.new
         step_mother.load_programming_language('rb')
         dsl = Object.new 
         dsl.extend Cucumber::RbSupport::RbDsl
@@ -45,7 +45,7 @@ module Cucumber
       end
 
       it "should store OS specific file paths" do
-        step_mother = Cucumber::StepMother.new
+        step_mother = Cucumber::Runtime.new
         step_mother.load_programming_language('rb')
         dsl = Object.new 
         dsl.extend Cucumber::RbSupport::RbDsl

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -8,7 +8,7 @@ module Cucumber
   module Ast
     describe ScenarioOutline do
       before do
-        @step_mother = Cucumber::StepMother.new
+        @step_mother = Cucumber::Runtime.new
         @step_mother.load_programming_language('rb')
         @dsl = Object.new
         @dsl.extend(Cucumber::RbSupport::RbDsl)

data/spec/cucumber/ast/scenario_spec.rb

@@ -7,7 +7,7 @@ module Cucumber
   module Ast
     describe Scenario do
       before do
-        @step_mother = Cucumber::StepMother.new
+        @step_mother = Cucumber::Runtime.new
         @step_mother.load_programming_language('rb')
         @dsl = Object.new
         @dsl.extend(Cucumber::RbSupport::RbDsl)
@@ -17,7 +17,6 @@ module Cucumber
           $y = n.to_i
         end
         @visitor = TreeWalker.new(@step_mother)
-        @visitor.options = {}
       end
 
       it "should skip steps when previous is not passed" do

data/spec/cucumber/ast/tree_walker_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 module Cucumber::Ast
   describe TreeWalker do
     it "should visit features" do
-      tw = TreeWalker.new(nil, [mock('listener', :before_visit_features => nil)], {})
+      tw = TreeWalker.new(nil, [mock('listener', :before_visit_features => nil)])
       tw.should_not_receive(:warn)
       tw.visit_features(mock('features', :accept => nil))
     end

data/spec/cucumber/cli/configuration_spec.rb

@@ -4,6 +4,9 @@ require 'yaml'
 module Cucumber
 module Cli
   describe Configuration do
+    module ExposesOptions
+      attr_reader :options
+    end
 
     def given_cucumber_yml_defined_as(hash_or_string)
       File.stub!(:exist?).and_return(true)
@@ -23,7 +26,7 @@ module Cli
     end
 
     def config
-      @config ||= Configuration.new(@out = StringIO.new, @error = StringIO.new)
+      @config ||= Configuration.new(@out = StringIO.new, @error = StringIO.new).extend(ExposesOptions)
     end
 
     def reset_config
@@ -287,17 +290,17 @@ END_OF_MESSAGE
 
     it "should accept --out option" do
       config.parse!(%w{--out jalla.txt})
-      config.options[:formats].should == [['pretty', 'jalla.txt']]
+      config.formats.should == [['pretty', 'jalla.txt']]
     end
 
     it "should accept multiple --out options" do
       config.parse!(%w{--format progress --out file1 --out file2})
-      config.options[:formats].should == [['progress', 'file2']]
+      config.formats.should == [['progress', 'file2']]
     end
 
     it "should accept multiple --format options and put the STDOUT one first so progress is seen" do
       config.parse!(%w{--format pretty --out pretty.txt --format progress})
-      config.options[:formats].should == [['progress', out], ['pretty', 'pretty.txt']]
+      config.formats.should == [['progress', out], ['pretty', 'pretty.txt']]
     end
 
     it "should not accept multiple --format options when both use implicit STDOUT" do
@@ -314,7 +317,7 @@ END_OF_MESSAGE
 
     it "should associate --out to previous --format" do
       config.parse!(%w{--format progress --out file1 --format profile --out file2})
-      config.options[:formats].should == [["progress", "file1"], ["profile" ,"file2"]]
+      config.formats.should == [["progress", "file1"], ["profile" ,"file2"]]
     end
 
     it "should accept --color option" do
@@ -399,7 +402,30 @@ END_OF_MESSAGE
       ENV["RAILS_ENV"].should == "selenium"
       config.feature_files.should_not include('RAILS_ENV=selenium')
     end
+    
+    describe "#tag_expression" do
+      it "returns an empty expression when no tags are specified" do
+        config.parse!([])
+        config.tag_expression.should be_empty
+      end
 
+      it "returns an expression when tags are specified" do
+        config.parse!(['--tags','@foo'])
+        config.tag_expression.should_not be_empty
+      end
+    end
+    
+    describe "#dry_run?" do
+      it "returns true when --dry-run was specified on in the arguments" do
+        config.parse!(['--dry-run'])
+        config.dry_run?.should be_true
+      end
+      
+      it "returns false by default" do
+        config.parse!([])
+        config.dry_run?.should be_false
+      end
+    end
   end
 end
 end

data/spec/cucumber/cli/drb_client_spec.rb

@@ -30,7 +30,7 @@ module Cucumber
 
       it "returns raises an error when it can't connect to the server" do
         DRbObject.stub!(:new_with_uri).and_raise(DRb::DRbConnError)
-        running { DRbClient.run(@args, @error_stream, @out_stream) }.should raise_error(DRbClientError, "No DRb server is running.")
+        lambda { DRbClient.run(@args, @error_stream, @out_stream) }.should raise_error(DRbClientError, "No DRb server is running.")
       end
 
       it "returns the result from the DRb server call" do

data/spec/cucumber/cli/main_spec.rb

@@ -24,7 +24,7 @@ module Cucumber
 
           Cucumber::FeatureFile.stub!(:new).and_return(mock("feature file", :parse => @empty_feature))
 
-          @cli.execute!(Cucumber::StepMother.new)
+          @cli.execute!
 
           @out.string.should include('example.feature')
         end
@@ -46,42 +46,12 @@ module Cucumber
             Object.should_receive(:const_get).with('ZooModule').and_return(mock_module)
             mock_module.should_receive(:const_get).with('MonkeyFormatterClass').and_return(mock('formatter class', :new => f))
 
-            cli.execute!(Cucumber::StepMother.new)
+            cli.execute!
           end
 
         end
       end
 
-      describe "setup step sequence" do
-        
-        it "should load files and execute hooks in order" do
-          Configuration.stub!(:new).and_return(configuration = mock('configuration').as_null_object)
-          step_mother = mock('step mother').as_null_object
-          configuration.stub!(:drb?).and_return false
-          cli = Main.new(%w{--verbose example.feature}, @out)
-          cli.stub!(:require)
-          
-          configuration.stub!(:support_to_load).and_return(['support'])
-          configuration.stub!(:step_defs_to_load).and_return(['step defs'])
-          
-          # Support must be loaded first to ensure post configuration hook can
-          # run before anything else.
-          step_mother.should_receive(:load_code_files).with(['support']).ordered
-          # The post configuration hook/s (if any) need to be run next to enable
-          # extensions to do their thing before features are loaded
-          step_mother.should_receive(:after_configuration).with(configuration).ordered
-          # Feature files must be loaded before step definitions are required.
-          # This is because i18n step methods are only aliased when
-          # features are loaded. If we swap the order, the requires
-          # will fail.
-          step_mother.should_receive(:load_plain_text_features).ordered
-          step_mother.should_receive(:load_code_files).with(['step defs']).ordered
-
-          cli.execute!(step_mother)
-        end
-        
-      end
-      
       [ProfilesNotDefinedError, YmlLoadError, ProfileNotFound].each do |exception_klass|
 
         it "rescues #{exception_klass}, prints the message to the error stream and returns true" do
@@ -89,7 +59,7 @@ module Cucumber
           configuration.stub!(:parse!).and_raise(exception_klass.new("error message"))
 
           main = Main.new('', out = StringIO.new, error = StringIO.new)
-          main.execute!(Cucumber::StepMother.new).should be_true
+          main.execute!.should be_true
           error.string.should == "error message\n"
         end
       end
@@ -103,30 +73,31 @@ module Cucumber
 
           @cli = Main.new(@args, @out, @err)
           @step_mother = mock('StepMother').as_null_object
+          StepMother.stub!(:new).and_return(@step_mother)
         end
 
         it "delegates the execution to the DRB client passing the args and streams" do
           @configuration.stub :drb_port => 1450
           DRbClient.should_receive(:run).with(@args, @err, @out, 1450).and_return(true)
-          @cli.execute!(@step_mother)
+          @cli.execute!
         end
 
         it "returns the result from the DRbClient" do
           DRbClient.stub!(:run).and_return('foo')
-          @cli.execute!(@step_mother).should == 'foo'
+          @cli.execute!.should == 'foo'
         end
 
         it "ceases execution if the DrbClient is able to perform the execution" do
           DRbClient.stub!(:run).and_return(true)
           @configuration.should_not_receive(:build_formatter_broadcaster)
-          @cli.execute!(@step_mother)
+          @cli.execute!
         end
 
         context "when the DrbClient is unable to perfrom the execution" do
           before { DRbClient.stub!(:run).and_raise(DRbClientError.new('error message.')) }
 
           it "alerts the user that execution will be performed locally" do
-            @cli.execute!(@step_mother)
+            @cli.execute!
             @err.string.should include("WARNING: error message. Running features locally:")
           end
 

data/spec/cucumber/cli/options_spec.rb

@@ -1,5 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'yaml'
+require 'cucumber/cli/options'
 
 module Cucumber
 module Cli
@@ -324,6 +325,25 @@ module Cli
 
     end
 
+    describe "dry-run" do 
+      it "should have the default value for snippets" do
+        given_cucumber_yml_defined_as({'foo' => %w[--dry-run]})
+        options.parse!(%w{--dry-run})
+        options[:snippets].should == true
+      end
+
+      it "should set snippets to false when no-snippets provided after dry-run" do 
+        given_cucumber_yml_defined_as({'foo' => %w[--dry-run --no-snippets]})
+        options.parse!(%w{--dry-run --no-snippets})
+        options[:snippets].should == false
+      end
+
+      it "should set snippets to false when no-snippets provided before dry-run" do 
+        given_cucumber_yml_defined_as({'foo' => %w[--no-snippet --dry-run]})
+        options.parse!(%w{--no-snippets --dry-run})
+        options[:snippets].should == false
+      end
+    end
   end
 
 end

data/spec/cucumber/formatter/spec_helper.rb

@@ -21,19 +21,21 @@ module Cucumber
       end
       
       def step_mother
-        @step_mother ||= StepMother.new
+        @step_mother ||= Runtime.new
       end
       
       def load_features(content)
         feature_file = FeatureFile.new('spec.feature', content)
         features = Ast::Features.new
-        feature = feature_file.parse(options, {})
+        filters = []
+        feature = feature_file.parse(filters, {})
         features.add_feature(feature) if feature
         features
       end
     
       def run(features)
-        tree_walker = Cucumber::Ast::TreeWalker.new(@step_mother, [@formatter], options, STDOUT)
+        configuration = Cucumber::Configuration.default
+        tree_walker = Cucumber::Ast::TreeWalker.new(@step_mother, [@formatter], configuration)
         tree_walker.visit_features(features)
       end
     
@@ -44,10 +46,6 @@ module Cucumber
         dsl.extend RbSupport::RbDsl
         dsl.instance_exec &step_defs
       end 
-
-      def options
-        @options ||= mock(Cucumber::Cli::Options, :filters => [], :[] => nil)
-      end
     end
   end
 end

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -6,9 +6,9 @@ require 'cucumber/rb_support/rb_language'
 module Cucumber
   module RbSupport
     describe RbStepDefinition do
+      let(:runtime) { Cucumber::Runtime.new }
       before do      
-        @step_mother = Cucumber::StepMother.new
-        @rb = @step_mother.load_programming_language('rb')
+        @rb = runtime.load_programming_language('rb')
       end
 
       def unindented(s)

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -8,7 +8,7 @@ module Cucumber
   module RbSupport
     describe RbStepDefinition do
       before do      
-        @step_mother = Cucumber::StepMother.new
+        @step_mother = Cucumber::Runtime.new
         @rb = @step_mother.load_programming_language('rb')
         @dsl = Object.new 
         @dsl.extend Cucumber::RbSupport::RbDsl

data/spec/cucumber/runtime_spec.rb

@@ -0,0 +1,294 @@
+require 'spec_helper'
+
+module Cucumber
+describe Runtime do
+  subject { Runtime.new(options) }
+  let(:options)     { {} }
+  let(:dsl) do
+    @rb = subject.load_programming_language('rb')
+    Object.new.extend(RbSupport::RbDsl)
+  end
+  
+  it "should format step names" do
+    dsl.Given(/it (.*) in (.*)/) { |what, month| }
+    dsl.Given(/nope something else/) { |what, month| }
+    
+    format = subject.step_match("it snows in april").format_args("[%s]")
+    format.should == "it [snows] in [april]"
+  end
+
+  describe "#features_paths" do
+    let(:options) { {:paths => ['foo/bar/baz.feature', 'foo/bar/features/baz.feature', 'other_features'] } }
+    it "returns the value from configuration.paths" do
+      subject.features_paths.should == options[:paths]
+    end
+  end
+  
+  describe "resolving step defintion matches" do
+
+    it "should raise Ambiguous error with guess hint when multiple step definitions match" do
+      expected_error = %{Ambiguous match of "Three blind mice":
+
+spec/cucumber/runtime_spec.rb:\\d+:in `/Three (.*) mice/'
+spec/cucumber/runtime_spec.rb:\\d+:in `/Three blind (.*)/'
+
+You can run again with --guess to make Cucumber be more smart about it
+}
+      dsl.Given(/Three (.*) mice/) {|disability|}
+      dsl.Given(/Three blind (.*)/) {|animal|}
+
+      lambda do
+        subject.step_match("Three blind mice")
+      end.should raise_error(Ambiguous, /#{expected_error}/)
+    end
+
+    describe "when --guess is used" do
+      let(:options) { {:guess => true} }
+
+      it "should not show --guess hint" do
+        expected_error = %{Ambiguous match of "Three cute mice":
+
+spec/cucumber/runtime_spec.rb:\\d+:in `/Three (.*) mice/'
+spec/cucumber/runtime_spec.rb:\\d+:in `/Three cute (.*)/'
+
+}
+        dsl.Given(/Three (.*) mice/) {|disability|}
+        dsl.Given(/Three cute (.*)/) {|animal|}
+
+        lambda do
+          subject.step_match("Three cute mice")
+        end.should raise_error(Ambiguous, /#{expected_error}/)
+      end
+
+      it "should not raise Ambiguous error when multiple step definitions match" do
+        dsl.Given(/Three (.*) mice/) {|disability|}
+        dsl.Given(/Three (.*)/) {|animal|}
+
+        lambda do
+          subject.step_match("Three blind mice")
+        end.should_not raise_error
+      end
+
+      it "should not raise NoMethodError when guessing from multiple step definitions with nil fields" do
+        dsl.Given(/Three (.*) mice( cannot find food)?/) {|disability, is_disastrous|}
+        dsl.Given(/Three (.*)?/) {|animal|}
+
+        lambda do
+          subject.step_match("Three blind mice")
+        end.should_not raise_error
+      end
+
+      it "should pick right step definition when an equal number of capture groups" do
+        right = dsl.Given(/Three (.*) mice/) {|disability|}
+        wrong = dsl.Given(/Three (.*)/) {|animal|}
+
+        subject.step_match("Three blind mice").step_definition.should == right
+      end
+
+      it "should pick right step definition when an unequal number of capture groups" do
+        right = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+        wrong = dsl.Given(/Three (.*)/) {|animal|}
+
+        subject.step_match("Three blind mice ran far").step_definition.should == right
+      end
+
+      it "should pick most specific step definition when an unequal number of capture groups" do
+        general       = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+        specific      = dsl.Given(/Three blind mice ran far/) do; end
+        more_specific = dsl.Given(/^Three blind mice ran far$/) do; end
+
+        subject.step_match("Three blind mice ran far").step_definition.should == more_specific
+      end
+    end
+
+    it "should raise Undefined error when no step definitions match" do
+      lambda do
+        subject.step_match("Three blind mice")
+      end.should raise_error(Undefined)
+    end
+
+    # http://railsforum.com/viewtopic.php?pid=93881
+    it "should not raise Redundant unless it's really redundant" do
+      dsl.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
+      dsl.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
+    end
+  end
+
+  describe "Handling the World" do
+
+    it "should raise an error if the world is nil" do
+      dsl.World {}
+
+      begin
+        subject.before_and_after(nil) do; end
+        raise "Should fail"
+      rescue RbSupport::NilWorld => e
+        e.message.should == "World procs should never return nil"
+        e.backtrace.length.should == 1
+        e.backtrace[0].should =~ /spec\/cucumber\/runtime_spec\.rb\:\d+\:in `World'/
+      end
+    end
+
+    module ModuleOne
+    end
+
+    module ModuleTwo
+    end
+
+    class ClassOne
+    end
+
+    it "should implicitly extend world with modules" do
+      dsl.World(ModuleOne, ModuleTwo)
+      subject.before(mock('scenario').as_null_object)
+      class << @rb.current_world
+        included_modules.inspect.should =~ /ModuleOne/ # Workaround for RSpec/Ruby 1.9 issue with namespaces
+        included_modules.inspect.should =~ /ModuleTwo/
+      end
+      @rb.current_world.class.should == Object
+    end
+
+    it "should raise error when we try to register more than one World proc" do
+      expected_error = %{You can only pass a proc to #World once, but it's happening
+in 2 places:
+
+spec/cucumber/runtime_spec.rb:\\d+:in `World'
+spec/cucumber/runtime_spec.rb:\\d+:in `World'
+
+Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc
+or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.
+
+}
+      dsl.World { Hash.new }
+      lambda do
+        dsl.World { Array.new }
+      end.should raise_error(RbSupport::MultipleWorld, /#{expected_error}/)
+
+    end
+  end
+
+  describe "hooks" do
+
+    it "should find before hooks" do
+      fish = dsl.Before('@fish'){}
+      meat = dsl.Before('@meat'){}
+
+      scenario = mock('Scenario')
+      scenario.should_receive(:accept_hook?).with(fish).and_return(true)
+      scenario.should_receive(:accept_hook?).with(meat).and_return(false)
+
+      @rb.hooks_for(:before, scenario).should == [fish]
+    end
+
+    it "should find around hooks" do
+      a = dsl.Around do |scenario, block|
+      end
+
+      b = dsl.Around('@tag') do |scenario, block|
+      end
+
+      scenario = mock('Scenario')
+      scenario.should_receive(:accept_hook?).with(a).and_return(true)
+      scenario.should_receive(:accept_hook?).with(b).and_return(false)
+
+      @rb.hooks_for(:around, scenario).should == [a]
+    end
+  end
+
+  describe "step argument transformations" do
+
+    describe "without capture groups" do
+      it "complains when registering with a with no transform block" do
+        lambda do
+          dsl.Transform('^abc$')
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when registering with a zero-arg transform block" do
+        lambda do
+          dsl.Transform('^abc$') {42}
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when registering with a splat-arg transform block" do
+        lambda do
+          dsl.Transform('^abc$') {|*splat| 42 }
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when transforming with an arity mismatch" do
+        lambda do
+          dsl.Transform('^abc$') {|one, two| 42 }
+          @rb.execute_transforms(['abc'])
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+
+      it "allows registering a regexp pattern that yields the step_arg matched" do
+        dsl.Transform(/^ab*c$/) {|arg| 42}
+        @rb.execute_transforms(['ab']).should == ['ab']
+        @rb.execute_transforms(['ac']).should == [42]
+        @rb.execute_transforms(['abc']).should == [42]
+        @rb.execute_transforms(['abbc']).should == [42]
+      end
+    end
+
+    describe "with capture groups" do
+      it "complains when registering with a with no transform block" do
+        lambda do
+          dsl.Transform('^a(.)c$')
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when registering with a zero-arg transform block" do
+        lambda do
+          dsl.Transform('^a(.)c$') { 42 }
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when registering with a splat-arg transform block" do
+        lambda do
+          dsl.Transform('^a(.)c$') {|*splat| 42 }
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+      end
+
+      it "complains when transforming with an arity mismatch" do
+        lambda do
+          dsl.Transform('^a(.)c$') {|one, two| 42 }
+          @rb.execute_transforms(['abc'])
+        end.should raise_error(Cucumber::ArityMismatchError)
+      end
+
+      it "allows registering a regexp pattern that yields capture groups" do
+        dsl.Transform(/^shape: (.+), color: (.+)$/) do |shape, color|
+          {shape.to_sym => color.to_sym}
+        end
+        @rb.execute_transforms(['shape: circle, color: blue']).should == [{:circle => :blue}]
+        @rb.execute_transforms(['shape: square, color: red']).should == [{:square => :red}]
+        @rb.execute_transforms(['not shape: square, not color: red']).should == ['not shape: square, not color: red']
+      end
+    end
+
+    it "allows registering a string pattern" do
+      dsl.Transform('^ab*c$') {|arg| 42}
+      @rb.execute_transforms(['ab']).should == ['ab']
+      @rb.execute_transforms(['ac']).should == [42]
+      @rb.execute_transforms(['abc']).should == [42]
+      @rb.execute_transforms(['abbc']).should == [42]
+    end
+
+    it "gives match priority to transforms defined last" do
+      dsl.Transform(/^transform_me$/) {|arg| :foo }
+      dsl.Transform(/^transform_me$/) {|arg| :bar }
+      dsl.Transform(/^transform_me$/) {|arg| :baz }
+      @rb.execute_transforms(['transform_me']).should == [:baz]
+    end
+
+    it "allows registering a transform which returns nil" do
+      dsl.Transform('^ac$') {|arg| nil}
+      @rb.execute_transforms(['ab']).should == ['ab']
+      @rb.execute_transforms(['ac']).should == [nil]
+    end
+  end
+
+end
+end