diff --git a/spec/integration/util/windows/user_spec.rb b/spec/integration/util/windows/user_spec.rb
index d3a94afc1..4e873b34c 100755
--- a/spec/integration/util/windows/user_spec.rb
+++ b/spec/integration/util/windows/user_spec.rb
@@ -1,106 +1,125 @@
 #! /usr/bin/env ruby
 
 require 'spec_helper'
 
 describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows? do
   describe "2003 without UAC" do
     before :each do
       Facter.stubs(:value).with(:kernelmajversion).returns("5.2")
     end
 
     it "should be an admin if user's token contains the Administrators SID" do
       Puppet::Util::Windows::User.expects(:check_token_membership).returns(true)
       Puppet::Util::Windows::Process.expects(:elevated_security?).never
 
       Puppet::Util::Windows::User.should be_admin
     end
 
     it "should not be an admin if user's token doesn't contain the Administrators SID" do
       Puppet::Util::Windows::User.expects(:check_token_membership).returns(false)
       Puppet::Util::Windows::Process.expects(:elevated_security?).never
 
       Puppet::Util::Windows::User.should_not be_admin
     end
 
     it "should raise an exception if we can't check token membership" do
       Puppet::Util::Windows::User.expects(:check_token_membership).raises(Puppet::Util::Windows::Error, "Access denied.")
       Puppet::Util::Windows::Process.expects(:elevated_security?).never
 
       lambda { Puppet::Util::Windows::User.admin? }.should raise_error(Puppet::Util::Windows::Error, /Access denied./)
     end
   end
 
   describe "2008 with UAC" do
     before :each do
       Facter.stubs(:value).with(:kernelmajversion).returns("6.0")
     end
 
     it "should be an admin if user is running with elevated privileges" do
       Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(true)
       Puppet::Util::Windows::User.expects(:check_token_membership).never
 
       Puppet::Util::Windows::User.should be_admin
     end
 
     it "should not be an admin if user is not running with elevated privileges" do
       Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(false)
       Puppet::Util::Windows::User.expects(:check_token_membership).never
 
       Puppet::Util::Windows::User.should_not be_admin
     end
 
     it "should raise an exception if the process fails to open the process token" do
       Puppet::Util::Windows::Process.stubs(:elevated_security?).raises(Puppet::Util::Windows::Error, "Access denied.")
       Puppet::Util::Windows::User.expects(:check_token_membership).never
 
       lambda { Puppet::Util::Windows::User.admin? }.should raise_error(Puppet::Util::Windows::Error, /Access denied./)
     end
   end
 
   describe "module function" do
     let(:username) { 'fabio' }
     let(:bad_password) { 'goldilocks' }
     let(:logon_fail_msg) { /Failed to logon user "fabio":  Logon failure: unknown user name or bad password./ }
 
+    def expect_logon_failure_error(&block)
+      expect {
+        yield
+      }.to raise_error { |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms681385(v=vs.85).aspx
+        # ERROR_LOGON_FAILURE 1326
+        expect(error.code).to eq(1326)
+      }
+    end
+
     describe "load_profile" do
       it "should raise an error when provided with an incorrect username and password" do
-        lambda { Puppet::Util::Windows::User.load_profile(username, bad_password) }.should raise_error(Puppet::Util::Windows::Error, logon_fail_msg)
+        expect_logon_failure_error {
+          Puppet::Util::Windows::User.load_profile(username, bad_password)
+        }
       end
 
       it "should raise an error when provided with an incorrect username and nil password" do
-        lambda { Puppet::Util::Windows::User.load_profile(username, nil) }.should raise_error(Puppet::Util::Windows::Error, logon_fail_msg)
+        expect_logon_failure_error {
+          Puppet::Util::Windows::User.load_profile(username, nil)
+        }
       end
     end
 
     describe "logon_user" do
       it "should raise an error when provided with an incorrect username and password" do
-        lambda { Puppet::Util::Windows::User.logon_user(username, bad_password) }.should raise_error(Puppet::Util::Windows::Error, logon_fail_msg)
+        expect_logon_failure_error {
+          Puppet::Util::Windows::User.logon_user(username, bad_password)
+        }
       end
 
       it "should raise an error when provided with an incorrect username and nil password" do
-        lambda { Puppet::Util::Windows::User.logon_user(username, nil) }.should raise_error(Puppet::Util::Windows::Error, logon_fail_msg)
+        expect_logon_failure_error {
+          Puppet::Util::Windows::User.logon_user(username, nil)
+        }
       end
     end
 
     describe "password_is?" do
       it "should return false given an incorrect username and password" do
         Puppet::Util::Windows::User.password_is?(username, bad_password).should be_false
       end
 
       it "should return false given an incorrect username and nil password" do
         Puppet::Util::Windows::User.password_is?(username, nil).should be_false
       end
 
       it "should return false given a nil username and an incorrect password" do
         Puppet::Util::Windows::User.password_is?(nil, bad_password).should be_false
       end
     end
 
     describe "check_token_membership" do
       it "should not raise an error" do
         # added just to call an FFI code path on all platforms
         lambda { Puppet::Util::Windows::User.check_token_membership }.should_not raise_error
       end
     end
   end
 end
diff --git a/spec/unit/application_spec.rb b/spec/unit/application_spec.rb
index b96f829d9..5043e93ce 100755
--- a/spec/unit/application_spec.rb
+++ b/spec/unit/application_spec.rb
@@ -1,645 +1,646 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/application'
 require 'puppet'
 require 'getoptlong'
 require 'timeout'
 
 describe Puppet::Application do
 
   before(:each) do
     Puppet::Util::Instrumentation.stubs(:init)
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
     @app.stubs(:name).returns("test_app")
 
   end
 
   describe "application commandline" do
     it "should not pick up changes to the array of arguments" do
       args = %w{subcommand --arg}
       command_line = Puppet::Util::CommandLine.new('puppet', args)
       app = Puppet::Application.new(command_line)
 
       args[0] = 'different_subcommand'
       args[1] = '--other-arg'
 
       app.command_line.subcommand_name.should == 'subcommand'
       app.command_line.args.should == ['--arg']
     end
   end
 
   describe "application defaults" do
     it "should fail if required app default values are missing" do
       @app.stubs(:app_defaults).returns({ :foo => 'bar' })
       Puppet.expects(:err).with(regexp_matches(/missing required app default setting/))
       expect {
         @app.run
       }.to exit_with 1
     end
   end
 
   describe "finding" do
     before do
       @klass = Puppet::Application
       @klass.stubs(:puts)
     end
 
     it "should find classes in the namespace" do
       @klass.find("Agent").should == @klass::Agent
     end
 
     it "should not find classes outside the namespace" do
       expect { @klass.find("String") }.to raise_error(LoadError)
     end
 
     it "should error if it can't find a class" do
       Puppet.expects(:err).with do |value|
         value =~ /Unable to find application 'ThisShallNeverEverEverExist'/ and
           value =~ /puppet\/application\/thisshallneverevereverexist/ and
           value =~ /no such file to load|cannot load such file/
       end
 
       expect {
         @klass.find("ThisShallNeverEverEverExist")
       }.to raise_error(LoadError)
     end
 
     it "#12114: should prevent File namespace collisions" do
       # have to require the file face once, then the second time around it would fail
       @klass.find("File").should == Puppet::Application::File
       @klass.find("File").should == Puppet::Application::File
     end
   end
 
   describe "#available_application_names" do
     it 'should be able to find available application names' do
       apps =  %w{describe filebucket kick queue resource agent cert apply doc master}
       Puppet::Util::Autoload.expects(:files_to_load).returns(apps)
 
       Puppet::Application.available_application_names.should =~ apps
     end
 
     it 'should find applications from multiple paths' do
       Puppet::Util::Autoload.expects(:files_to_load).with('puppet/application').returns(%w{ /a/foo.rb /b/bar.rb })
 
       Puppet::Application.available_application_names.should =~ %w{ foo bar }
     end
 
     it 'should return unique application names' do
       Puppet::Util::Autoload.expects(:files_to_load).with('puppet/application').returns(%w{ /a/foo.rb /b/foo.rb })
 
       Puppet::Application.available_application_names.should == %w{ foo }
     end
   end
 
   describe ".run_mode" do
     it "should default to user" do
       @appclass.run_mode.name.should == :user
     end
 
     it "should set and get a value" do
       @appclass.run_mode :agent
       @appclass.run_mode.name.should == :agent
     end
   end
 
 
 
   # These tests may look a little weird and repetative in its current state;
   #  it used to illustrate several ways that the run_mode could be changed
   #  at run time; there are fewer ways now, but it would still be nice to
   #  get to a point where it was entirely impossible.
   describe "when dealing with run_mode" do
 
     class TestApp < Puppet::Application
       run_mode :master
       def run_command
         # no-op
       end
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #initialize_app_defaults" do
       Puppet.features.stubs(:syslog?).returns(true)
 
       app = TestApp.new
       app.initialize_app_defaults
 
       Puppet.run_mode.should be_master
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #run" do
       app = TestApp.new
       app.run
 
       app.class.run_mode.name.should == :master
 
       Puppet.run_mode.should be_master
     end
   end
 
   it "should explode when an invalid run mode is set at runtime, for great victory" do
     expect {
       class InvalidRunModeTestApp < Puppet::Application
         run_mode :abracadabra
         def run_command
           # no-op
         end
       end
     }.to raise_error
   end
 
   it "should have a run entry-point" do
     @app.should respond_to(:run)
   end
 
   it "should have a read accessor to options" do
     @app.should respond_to(:options)
   end
 
   it "should include a default setup method" do
     @app.should respond_to(:setup)
   end
 
   it "should include a default preinit method" do
     @app.should respond_to(:preinit)
   end
 
   it "should include a default run_command method" do
     @app.should respond_to(:run_command)
   end
 
   it "should invoke main as the default" do
     @app.expects( :main )
     @app.run_command
   end
 
   it "should initialize the Puppet Instrumentation layer early in the life cycle" do
+    pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
     # Not proud of this, but the fact that we are stubbing init_app_defaults
     #  below means that we will get errors if anyone tries to access any
     #  settings that depend on app_defaults.  In general this whole test
     #  seems to be testing too many implementation details rather than
     #  functionality, but, hey.
     Puppet[:route_file] = "/dev/null"
 
     startup_sequence = sequence('startup')
     @app.expects(:initialize_app_defaults).in_sequence(startup_sequence)
     Puppet::Util::Instrumentation.expects(:init).in_sequence(startup_sequence)
     @app.expects(:preinit).in_sequence(startup_sequence)
 
     expect { @app.run }.to exit_with(1)
   end
 
   describe 'when invoking clear!' do
     before :each do
       Puppet::Application.run_status = :stop_requested
       Puppet::Application.clear!
     end
 
     it 'should have nil run_status' do
       Puppet::Application.run_status.should be_nil
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return false for interrupted?' do
       Puppet::Application.interrupted?.should be_false
     end
 
     it 'should return true for clear?' do
       Puppet::Application.clear?.should be_true
     end
   end
 
   describe 'after invoking stop!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.stop!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :stop_requested' do
       Puppet::Application.run_status.should == :stop_requested
     end
 
     it 'should return true for stop_requested?' do
       Puppet::Application.stop_requested?.should be_true
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when invoking restart!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.restart!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :restart_requested' do
       Puppet::Application.run_status.should == :restart_requested
     end
 
     it 'should return true for restart_requested?' do
       Puppet::Application.restart_requested?.should be_true
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when performing a controlled_run' do
     it 'should not execute block if not :clear?' do
       Puppet::Application.run_status = :stop_requested
       target = mock 'target'
       target.expects(:some_method).never
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
     it 'should execute block if :clear?' do
       Puppet::Application.run_status = nil
       target = mock 'target'
       target.expects(:some_method).once
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
     describe 'on POSIX systems', :if => Puppet.features.posix? do
       it 'should signal process with HUP after block if restart requested during block execution' do
         Timeout::timeout(3) do  # if the signal doesn't fire, this causes failure.
 
           has_run = false
           old_handler = trap('HUP') { has_run = true }
 
           begin
             Puppet::Application.controlled_run do
               Puppet::Application.run_status = :restart_requested
             end
 
             # Ruby 1.9 uses a separate OS level thread to run the signal
             # handler, so we have to poll - ideally, in a way that will kick
             # the OS into running other threads - for a while.
             #
             # You can't just use the Ruby Thread yield thing either, because
             # that is just an OS hint, and Linux ... doesn't take that
             # seriously. --daniel 2012-03-22
             sleep 0.001 while not has_run
           ensure
             trap('HUP', old_handler)
           end
         end
       end
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
   end
 
   describe "when parsing command-line options" do
 
     before :each do
       @app.command_line.stubs(:args).returns([])
 
       Puppet.settings.stubs(:optparse_addargs).returns([])
     end
 
     it "should pass the banner to the option parser" do
       option_parser = stub "option parser"
       option_parser.stubs(:on)
       option_parser.stubs(:parse!)
       @app.class.instance_eval do
         banner "banner"
       end
 
       OptionParser.expects(:new).with("banner").returns(option_parser)
 
       @app.parse_options
     end
 
     it "should ask OptionParser to parse the command-line argument" do
       @app.command_line.stubs(:args).returns(%w{ fake args })
       OptionParser.any_instance.expects(:parse!).with(%w{ fake args })
 
       @app.parse_options
     end
 
     describe "when using --help" do
 
       it "should call exit" do
         @app.stubs(:puts)
         expect { @app.handle_help(nil) }.to exit_with 0
       end
 
     end
 
     describe "when using --version" do
       it "should declare a version option" do
         @app.should respond_to(:handle_version)
       end
 
       it "should exit after printing the version" do
         @app.stubs(:puts)
         expect { @app.handle_version(nil) }.to exit_with 0
       end
     end
 
     describe "when dealing with an argument not declared directly by the application" do
       it "should pass it to handle_unknown if this method exists" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled", :REQUIRED]])
 
         @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
         @app.command_line.stubs(:args).returns(["--not-handled", "value"])
         @app.parse_options
       end
 
       it "should transform boolean option to normal form for Puppet.settings" do
         @app.expects(:handle_unknown).with("--option", true)
         @app.send(:handlearg, "--[no-]option", true)
       end
 
       it "should transform boolean option to no- form for Puppet.settings" do
         @app.expects(:handle_unknown).with("--no-option", false)
         @app.send(:handlearg, "--[no-]option", false)
       end
 
     end
   end
 
   describe "when calling default setup" do
 
     before :each do
       @app.options.stubs(:[])
     end
 
     [ :debug, :verbose ].each do |level|
       it "should honor option #{level}" do
         @app.options.stubs(:[]).with(level).returns(true)
         Puppet::Util::Log.stubs(:newdestination)
         @app.setup
         Puppet::Util::Log.level.should == (level == :verbose ? :info : :debug)
       end
     end
 
     it "should honor setdest option" do
       @app.options.stubs(:[]).with(:setdest).returns(false)
 
       Puppet::Util::Log.expects(:setup_default)
 
       @app.setup
     end
 
   end
 
   describe "when configuring routes" do
     include PuppetSpec::Files
 
     before :each do
       Puppet::Node.indirection.reset_terminus_class
     end
 
     after :each do
       Puppet::Node.indirection.reset_terminus_class
     end
 
     it "should use the routes specified for only the active application" do
       Puppet[:route_file] = tmpfile('routes')
       File.open(Puppet[:route_file], 'w') do |f|
         f.print <<-ROUTES
           test_app:
             node:
               terminus: exec
           other_app:
             node:
               terminus: plain
             catalog:
               terminus: invalid
         ROUTES
       end
 
       @app.configure_indirector_routes
 
       Puppet::Node.indirection.terminus_class.should == 'exec'
     end
 
     it "should not fail if the route file doesn't exist" do
       Puppet[:route_file] = "/dev/null/non-existent"
 
       expect { @app.configure_indirector_routes }.to_not raise_error
     end
 
     it "should raise an error if the routes file is invalid" do
       Puppet[:route_file] = tmpfile('routes')
       File.open(Puppet[:route_file], 'w') do |f|
         f.print <<-ROUTES
          invalid : : yaml
         ROUTES
       end
 
       expect { @app.configure_indirector_routes }.to raise_error
     end
   end
 
   describe "when running" do
 
     before :each do
       @app.stubs(:preinit)
       @app.stubs(:setup)
       @app.stubs(:parse_options)
     end
 
     it "should call preinit" do
       @app.stubs(:run_command)
 
       @app.expects(:preinit)
 
       @app.run
     end
 
     it "should call parse_options" do
       @app.stubs(:run_command)
 
       @app.expects(:parse_options)
 
       @app.run
     end
 
     it "should call run_command" do
 
       @app.expects(:run_command)
 
       @app.run
     end
 
 
     it "should call run_command" do
       @app.expects(:run_command)
 
       @app.run
     end
 
     it "should call main as the default command" do
       @app.expects(:main)
 
       @app.run
     end
 
     it "should warn and exit if no command can be called" do
       Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns no command" do
       @app.stubs(:get_command).returns(nil)
       Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns an invalid command" do
       @app.stubs(:get_command).returns(:this_function_doesnt_exist)
       Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
   end
 
   describe "when metaprogramming" do
 
     describe "when calling option" do
       it "should create a new method named after the option" do
         @app.class.option("--test1","-t") do
         end
 
         @app.should respond_to(:handle_test1)
       end
 
       it "should transpose in option name any '-' into '_'" do
         @app.class.option("--test-dashes-again","-t") do
         end
 
         @app.should respond_to(:handle_test_dashes_again)
       end
 
       it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
         @app.class.option("--[no-]test2","-t") do
         end
 
         @app.should respond_to(:handle_test2)
       end
 
       describe "when a block is passed" do
         it "should create a new method with it" do
           @app.class.option("--[no-]test2","-t") do
             raise "I can't believe it, it works!"
           end
 
           expect { @app.handle_test2 }.to raise_error
         end
 
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
 
           @app.class.option("--[no-]test3","-t") do
           end
 
           @app.parse_options
         end
 
         it "should pass a block that calls our defined method" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with('--test4','-t').yields(nil)
 
           @app.expects(:send).with(:handle_test4, nil)
 
           @app.class.option("--test4","-t") do
           end
 
           @app.parse_options
         end
       end
 
       describe "when no block is given" do
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with("--test4","-t")
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
 
         it "should give to OptionParser a block that adds the value to the options array" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with("--test4","-t").yields(nil)
 
           @app.options.expects(:[]=).with(:test4,nil)
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
       end
     end
 
   end
 
   describe "#handle_logdest_arg" do
 
     let(:test_arg) { "arg_test_logdest" }
 
     it "should log an exception that is raised" do
       our_exception = Puppet::DevError.new("test exception")
       Puppet::Util::Log.expects(:newdestination).with(test_arg).raises(our_exception)
       Puppet.expects(:log_exception).with(our_exception)
       @app.handle_logdest_arg(test_arg)
     end
 
     it "should set the new log destination" do
       Puppet::Util::Log.expects(:newdestination).with(test_arg)
       @app.handle_logdest_arg(test_arg)
     end
 
     it "should set the flag that a destination is set in the options hash" do
       Puppet::Util::Log.stubs(:newdestination).with(test_arg)
       @app.handle_logdest_arg(test_arg)
       @app.options[:setdest].should be_true
     end
   end
 
 end
diff --git a/spec/unit/provider/scheduled_task/win32_taskscheduler_spec.rb b/spec/unit/provider/scheduled_task/win32_taskscheduler_spec.rb
index 7a6215603..f718f37ba 100644
--- a/spec/unit/provider/scheduled_task/win32_taskscheduler_spec.rb
+++ b/spec/unit/provider/scheduled_task/win32_taskscheduler_spec.rb
@@ -1,1574 +1,1585 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'win32/taskscheduler' if Puppet.features.microsoft_windows?
 
 shared_examples_for "a trigger that handles start_date and start_time" do
   let(:trigger) do
     described_class.new(
       :name => 'Shared Test Task',
       :command => 'C:\Windows\System32\notepad.exe'
     ).translate_hash_to_trigger(trigger_hash)
   end
 
   before :each do
     Win32::TaskScheduler.any_instance.stubs(:save)
   end
 
   describe 'the given start_date' do
     before :each do
       trigger_hash['start_time'] = '00:00'
     end
 
     def date_component
       {
         'start_year'  => trigger['start_year'],
         'start_month' => trigger['start_month'],
         'start_day'   => trigger['start_day']
       }
     end
 
     it 'should be able to be specified in ISO 8601 calendar date format' do
       trigger_hash['start_date'] = '2011-12-31'
 
       date_component.should == {
         'start_year'  => 2011,
         'start_month' => 12,
         'start_day'   => 31
       }
     end
 
     it 'should fail if before 1753-01-01' do
       trigger_hash['start_date'] = '1752-12-31'
 
       expect { date_component }.to raise_error(
         Puppet::Error,
         'start_date must be on or after 1753-01-01'
       )
     end
 
     it 'should succeed if on 1753-01-01' do
       trigger_hash['start_date'] = '1753-01-01'
 
       date_component.should == {
         'start_year'  => 1753,
         'start_month' => 1,
         'start_day'   => 1
       }
     end
 
     it 'should succeed if after 1753-01-01' do
       trigger_hash['start_date'] = '1753-01-02'
 
       date_component.should == {
         'start_year'  => 1753,
         'start_month' => 1,
         'start_day'   => 2
       }
     end
   end
 
   describe 'the given start_time' do
     before :each do
       trigger_hash['start_date'] = '2011-12-31'
     end
 
     def time_component
       {
         'start_hour'   => trigger['start_hour'],
         'start_minute' => trigger['start_minute']
       }
     end
 
     it 'should be able to be specified as a 24-hour "hh:mm"' do
       trigger_hash['start_time'] = '17:13'
 
       time_component.should == {
         'start_hour'   => 17,
         'start_minute' => 13
       }
     end
 
     it 'should be able to be specified as a 12-hour "hh:mm am"' do
       trigger_hash['start_time'] = '3:13 am'
 
       time_component.should == {
         'start_hour'   => 3,
         'start_minute' => 13
       }
     end
 
     it 'should be able to be specified as a 12-hour "hh:mm pm"' do
       trigger_hash['start_time'] = '3:13 pm'
 
       time_component.should == {
         'start_hour'   => 15,
         'start_minute' => 13
       }
     end
   end
 end
 
 describe Puppet::Type.type(:scheduled_task).provider(:win32_taskscheduler), :if => Puppet.features.microsoft_windows? do
   before :each do
     Puppet::Type.type(:scheduled_task).stubs(:defaultprovider).returns(described_class)
   end
 
   describe 'when retrieving' do
     before :each do
       @mock_task = mock
       @mock_task.responds_like(Win32::TaskScheduler.new)
       described_class.any_instance.stubs(:task).returns(@mock_task)
 
       Win32::TaskScheduler.stubs(:new).returns(@mock_task)
     end
     let(:resource) { Puppet::Type.type(:scheduled_task).new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe') }
 
     describe 'the triggers for a task' do
       describe 'with only one trigger' do
         before :each do
           @mock_task.expects(:trigger_count).returns(1)
         end
 
         it 'should handle a single daily trigger' do
           @mock_task.expects(:trigger).with(0).returns({
             'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_DAILY,
             'start_year'   => 2011,
             'start_month'  => 9,
             'start_day'    => 12,
             'start_hour'   => 13,
             'start_minute' => 20,
             'flags'        => 0,
             'type'         => { 'days_interval' => 2 },
           })
 
           resource.provider.trigger.should == {
             'start_date' => '2011-9-12',
             'start_time' => '13:20',
             'schedule'   => 'daily',
             'every'      => '2',
             'enabled'    => true,
             'index'      => 0,
           }
         end
 
         it 'should handle a single weekly trigger' do
           scheduled_days_of_week = Win32::TaskScheduler::MONDAY |
                                    Win32::TaskScheduler::WEDNESDAY |
                                    Win32::TaskScheduler::FRIDAY |
                                    Win32::TaskScheduler::SUNDAY
           @mock_task.expects(:trigger).with(0).returns({
             'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_WEEKLY,
             'start_year'   => 2011,
             'start_month'  => 9,
             'start_day'    => 12,
             'start_hour'   => 13,
             'start_minute' => 20,
             'flags'        => 0,
             'type'         => {
               'weeks_interval' => 2,
               'days_of_week'   => scheduled_days_of_week
             }
           })
 
           resource.provider.trigger.should == {
             'start_date' => '2011-9-12',
             'start_time' => '13:20',
             'schedule'   => 'weekly',
             'every'      => '2',
             'on'         => ['sun', 'mon', 'wed', 'fri'],
             'enabled'    => true,
             'index'      => 0,
           }
         end
 
         it 'should handle a single monthly date-based trigger' do
           scheduled_months = Win32::TaskScheduler::JANUARY |
                              Win32::TaskScheduler::FEBRUARY |
                              Win32::TaskScheduler::AUGUST |
                              Win32::TaskScheduler::SEPTEMBER |
                              Win32::TaskScheduler::DECEMBER
           #                1   3        5        15        'last'
           scheduled_days = 1 | 1 << 2 | 1 << 4 | 1 << 14 | 1 << 31
           @mock_task.expects(:trigger).with(0).returns({
             'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDATE,
             'start_year'   => 2011,
             'start_month'  => 9,
             'start_day'    => 12,
             'start_hour'   => 13,
             'start_minute' => 20,
             'flags'        => 0,
             'type'         => {
               'months' => scheduled_months,
               'days'   => scheduled_days
             }
           })
 
           resource.provider.trigger.should == {
             'start_date' => '2011-9-12',
             'start_time' => '13:20',
             'schedule'   => 'monthly',
             'months'     => [1, 2, 8, 9, 12],
             'on'         => [1, 3, 5, 15, 'last'],
             'enabled'    => true,
             'index'      => 0,
           }
         end
 
         it 'should handle a single monthly day-of-week-based trigger' do
           scheduled_months = Win32::TaskScheduler::JANUARY |
                              Win32::TaskScheduler::FEBRUARY |
                              Win32::TaskScheduler::AUGUST |
                              Win32::TaskScheduler::SEPTEMBER |
                              Win32::TaskScheduler::DECEMBER
           scheduled_days_of_week = Win32::TaskScheduler::MONDAY |
                                    Win32::TaskScheduler::WEDNESDAY |
                                    Win32::TaskScheduler::FRIDAY |
                                    Win32::TaskScheduler::SUNDAY
           @mock_task.expects(:trigger).with(0).returns({
             'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_MONTHLYDOW,
             'start_year'   => 2011,
             'start_month'  => 9,
             'start_day'    => 12,
             'start_hour'   => 13,
             'start_minute' => 20,
             'flags'        => 0,
             'type'         => {
               'months'       => scheduled_months,
               'weeks'        => Win32::TaskScheduler::FIRST_WEEK,
               'days_of_week' => scheduled_days_of_week
             }
           })
 
           resource.provider.trigger.should == {
             'start_date'       => '2011-9-12',
             'start_time'       => '13:20',
             'schedule'         => 'monthly',
             'months'           => [1, 2, 8, 9, 12],
             'which_occurrence' => 'first',
             'day_of_week'      => ['sun', 'mon', 'wed', 'fri'],
             'enabled'          => true,
             'index'            => 0,
           }
         end
 
         it 'should handle a single one-time trigger' do
           @mock_task.expects(:trigger).with(0).returns({
             'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
             'start_year'   => 2011,
             'start_month'  => 9,
             'start_day'    => 12,
             'start_hour'   => 13,
             'start_minute' => 20,
             'flags'        => 0,
           })
 
           resource.provider.trigger.should == {
             'start_date' => '2011-9-12',
             'start_time' => '13:20',
             'schedule'   => 'once',
             'enabled'    => true,
             'index'      => 0,
           }
         end
       end
 
       it 'should handle multiple triggers' do
         @mock_task.expects(:trigger_count).returns(3)
         @mock_task.expects(:trigger).with(0).returns({
           'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
           'start_year'   => 2011,
           'start_month'  => 10,
           'start_day'    => 13,
           'start_hour'   => 14,
           'start_minute' => 21,
           'flags'        => 0,
         })
         @mock_task.expects(:trigger).with(1).returns({
           'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
           'start_year'   => 2012,
           'start_month'  => 11,
           'start_day'    => 14,
           'start_hour'   => 15,
           'start_minute' => 22,
           'flags'        => 0,
         })
         @mock_task.expects(:trigger).with(2).returns({
           'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
           'start_year'   => 2013,
           'start_month'  => 12,
           'start_day'    => 15,
           'start_hour'   => 16,
           'start_minute' => 23,
           'flags'        => 0,
         })
 
         resource.provider.trigger.should =~ [
           {
             'start_date' => '2011-10-13',
             'start_time' => '14:21',
             'schedule'   => 'once',
             'enabled'    => true,
             'index'      => 0,
           },
           {
             'start_date' => '2012-11-14',
             'start_time' => '15:22',
             'schedule'   => 'once',
             'enabled'    => true,
             'index'      => 1,
           },
           {
             'start_date' => '2013-12-15',
             'start_time' => '16:23',
             'schedule'   => 'once',
             'enabled'    => true,
             'index'      => 2,
           }
         ]
       end
 
       it 'should skip triggers Win32::TaskScheduler cannot handle' do
         @mock_task.expects(:trigger_count).returns(3)
         @mock_task.expects(:trigger).with(0).returns({
           'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
           'start_year'   => 2011,
           'start_month'  => 10,
           'start_day'    => 13,
           'start_hour'   => 14,
           'start_minute' => 21,
           'flags'        => 0,
         })
         @mock_task.expects(:trigger).with(1).raises(
           Win32::TaskScheduler::Error.new('Unhandled trigger type!')
         )
         @mock_task.expects(:trigger).with(2).returns({
           'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
           'start_year'   => 2013,
           'start_month'  => 12,
           'start_day'    => 15,
           'start_hour'   => 16,
           'start_minute' => 23,
           'flags'        => 0,
         })
 
         resource.provider.trigger.should =~ [
           {
             'start_date' => '2011-10-13',
             'start_time' => '14:21',
             'schedule'   => 'once',
             'enabled'    => true,
             'index'      => 0,
           },
           {
             'start_date' => '2013-12-15',
             'start_time' => '16:23',
             'schedule'   => 'once',
             'enabled'    => true,
             'index'      => 2,
           }
         ]
       end
 
       it 'should skip trigger types Puppet does not handle' do
         @mock_task.expects(:trigger_count).returns(3)
         @mock_task.expects(:trigger).with(0).returns({
           'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
           'start_year'   => 2011,
           'start_month'  => 10,
           'start_day'    => 13,
           'start_hour'   => 14,
           'start_minute' => 21,
           'flags'        => 0,
         })
         @mock_task.expects(:trigger).with(1).returns({
           'trigger_type' => Win32::TaskScheduler::TASK_EVENT_TRIGGER_AT_LOGON,
         })
         @mock_task.expects(:trigger).with(2).returns({
           'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
           'start_year'   => 2013,
           'start_month'  => 12,
           'start_day'    => 15,
           'start_hour'   => 16,
           'start_minute' => 23,
           'flags'        => 0,
         })
 
         resource.provider.trigger.should =~ [
           {
             'start_date' => '2011-10-13',
             'start_time' => '14:21',
             'schedule'   => 'once',
             'enabled'    => true,
             'index'      => 0,
           },
           {
             'start_date' => '2013-12-15',
             'start_time' => '16:23',
             'schedule'   => 'once',
             'enabled'    => true,
             'index'      => 2,
           }
         ]
       end
     end
 
     it 'should get the working directory from the working_directory on the task' do
       @mock_task.expects(:working_directory).returns('C:\Windows\System32')
 
       resource.provider.working_dir.should == 'C:\Windows\System32'
     end
 
     it 'should get the command from the application_name on the task' do
       @mock_task.expects(:application_name).returns('C:\Windows\System32\notepad.exe')
 
       resource.provider.command.should == 'C:\Windows\System32\notepad.exe'
     end
 
     it 'should get the command arguments from the parameters on the task' do
       @mock_task.expects(:parameters).returns('these are my arguments')
 
       resource.provider.arguments.should == 'these are my arguments'
     end
 
     it 'should get the user from the account_information on the task' do
       @mock_task.expects(:account_information).returns('this is my user')
 
       resource.provider.user.should == 'this is my user'
     end
 
     describe 'whether the task is enabled' do
       it 'should report tasks with the disabled bit set as disabled' do
+        pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
         @mock_task.stubs(:flags).returns(Win32::TaskScheduler::DISABLED)
 
         resource.provider.enabled.should == :false
       end
 
       it 'should report tasks without the disabled bit set as enabled' do
+        pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
         @mock_task.stubs(:flags).returns(~Win32::TaskScheduler::DISABLED)
 
         resource.provider.enabled.should == :true
       end
 
       it 'should not consider triggers for determining if the task is enabled' do
+        pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
         @mock_task.stubs(:flags).returns(~Win32::TaskScheduler::DISABLED)
         @mock_task.stubs(:trigger_count).returns(1)
         @mock_task.stubs(:trigger).with(0).returns({
           'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
           'start_year'   => 2011,
           'start_month'  => 10,
           'start_day'    => 13,
           'start_hour'   => 14,
           'start_minute' => 21,
           'flags'        => Win32::TaskScheduler::TASK_TRIGGER_FLAG_DISABLED,
         })
 
         resource.provider.enabled.should == :true
       end
     end
   end
 
   describe '#exists?' do
     before :each do
       @mock_task = mock
       @mock_task.responds_like(Win32::TaskScheduler.new)
       described_class.any_instance.stubs(:task).returns(@mock_task)
 
       Win32::TaskScheduler.stubs(:new).returns(@mock_task)
     end
     let(:resource) { Puppet::Type.type(:scheduled_task).new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe') }
 
     it "should delegate to Win32::TaskScheduler using the resource's name" do
       @mock_task.expects(:exists?).with('Test Task').returns(true)
 
       resource.provider.exists?.should == true
     end
   end
 
   describe '#clear_task' do
     before :each do
       @mock_task     = mock
       @new_mock_task = mock
       @mock_task.responds_like(Win32::TaskScheduler.new)
       @new_mock_task.responds_like(Win32::TaskScheduler.new)
       Win32::TaskScheduler.stubs(:new).returns(@mock_task, @new_mock_task)
 
       described_class.any_instance.stubs(:exists?).returns(false)
     end
     let(:resource) { Puppet::Type.type(:scheduled_task).new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe') }
 
     it 'should clear the cached task object' do
       resource.provider.task.should == @mock_task
       resource.provider.task.should == @mock_task
 
       resource.provider.clear_task
 
       resource.provider.task.should == @new_mock_task
     end
 
     it 'should clear the cached list of triggers for the task' do
       @mock_task.stubs(:trigger_count).returns(1)
       @mock_task.stubs(:trigger).with(0).returns({
         'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
         'start_year'   => 2011,
         'start_month'  => 10,
         'start_day'    => 13,
         'start_hour'   => 14,
         'start_minute' => 21,
         'flags'        => 0,
       })
       @new_mock_task.stubs(:trigger_count).returns(1)
       @new_mock_task.stubs(:trigger).with(0).returns({
         'trigger_type' => Win32::TaskScheduler::TASK_TIME_TRIGGER_ONCE,
         'start_year'   => 2012,
         'start_month'  => 11,
         'start_day'    => 14,
         'start_hour'   => 15,
         'start_minute' => 22,
         'flags'        => 0,
       })
 
       mock_task_trigger = {
         'start_date' => '2011-10-13',
         'start_time' => '14:21',
         'schedule'   => 'once',
         'enabled'    => true,
         'index'      => 0,
       }
 
       resource.provider.trigger.should == mock_task_trigger
       resource.provider.trigger.should == mock_task_trigger
 
       resource.provider.clear_task
 
       resource.provider.trigger.should == {
         'start_date' => '2012-11-14',
         'start_time' => '15:22',
         'schedule'   => 'once',
         'enabled'    => true,
         'index'      => 0,
       }
     end
   end
 
   describe '.instances' do
     it 'should use the list of .job files to construct the list of scheduled_tasks' do
       job_files = ['foo.job', 'bar.job', 'baz.job']
       Win32::TaskScheduler.any_instance.stubs(:tasks).returns(job_files)
       job_files.each do |job|
         job = File.basename(job, '.job')
 
         described_class.expects(:new).with(:provider => :win32_taskscheduler, :name => job)
       end
 
       described_class.instances
     end
   end
 
   describe '#user_insync?', :if => Puppet.features.microsoft_windows? do
     let(:resource) { described_class.new(:name => 'foobar', :command => 'C:\Windows\System32\notepad.exe') }
 
     it 'should consider the user as in sync if the name matches' do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('joe').twice.returns('SID A')
 
       resource.should be_user_insync('joe', ['joe'])
     end
 
     it 'should consider the user as in sync if the current user is fully qualified' do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('joe').returns('SID A')
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('MACHINE\joe').returns('SID A')
 
       resource.should be_user_insync('MACHINE\joe', ['joe'])
     end
 
     it 'should consider a current user of the empty string to be the same as the system user' do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('system').twice.returns('SYSTEM SID')
 
       resource.should be_user_insync('', ['system'])
     end
 
     it 'should consider different users as being different' do
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('joe').returns('SID A')
       Puppet::Util::Windows::SID.expects(:name_to_sid).with('bob').returns('SID B')
 
       resource.should_not be_user_insync('joe', ['bob'])
     end
   end
 
   describe '#trigger_insync?' do
     let(:resource) { described_class.new(:name => 'foobar', :command => 'C:\Windows\System32\notepad.exe') }
 
     it 'should not consider any extra current triggers as in sync' do
       current = [
         {'start_date' => '2011-09-12', 'start_time' => '15:15', 'schedule' => 'once'},
         {'start_date' => '2012-10-13', 'start_time' => '16:16', 'schedule' => 'once'}
       ]
       desired = {'start_date' => '2011-09-12', 'start_time' => '15:15', 'schedule' => 'once'}
 
       resource.should_not be_trigger_insync(current, desired)
     end
 
     it 'should not consider any extra desired triggers as in sync' do
       current = {'start_date' => '2011-09-12', 'start_time' => '15:15', 'schedule' => 'once'}
       desired = [
         {'start_date' => '2011-09-12', 'start_time' => '15:15', 'schedule' => 'once'},
         {'start_date' => '2012-10-13', 'start_time' => '16:16', 'schedule' => 'once'}
       ]
 
       resource.should_not be_trigger_insync(current, desired)
     end
 
     it 'should consider triggers to be in sync if the sets of current and desired triggers are equal' do
       current = [
         {'start_date' => '2011-09-12', 'start_time' => '15:15', 'schedule' => 'once'},
         {'start_date' => '2012-10-13', 'start_time' => '16:16', 'schedule' => 'once'}
       ]
       desired = [
         {'start_date' => '2011-09-12', 'start_time' => '15:15', 'schedule' => 'once'},
         {'start_date' => '2012-10-13', 'start_time' => '16:16', 'schedule' => 'once'}
       ]
 
       resource.should be_trigger_insync(current, desired)
     end
   end
 
   describe '#triggers_same?' do
     let(:provider) { described_class.new(:name => 'foobar', :command => 'C:\Windows\System32\notepad.exe') }
 
     it "should not consider a disabled 'current' trigger to be the same" do
       current = {'schedule' => 'once', 'enabled' => false}
       desired = {'schedule' => 'once'}
 
       provider.should_not be_triggers_same(current, desired)
     end
 
     it 'should not consider triggers with different schedules to be the same' do
       current = {'schedule' => 'once'}
       desired = {'schedule' => 'weekly'}
 
       provider.should_not be_triggers_same(current, desired)
     end
 
     describe 'comparing daily triggers' do
       it "should consider 'desired' triggers not specifying 'every' to have the same value as the 'current' trigger" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30'}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_dates' as different triggers" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'daily', 'start_date' => '2012-09-12', 'start_time' => '15:30', 'every' => 3}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:31', 'every' => 3}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in date formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-9-12',  'start_time' => '15:30', 'every' => 3}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in time formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '5:30',  'every' => 3}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '05:30', 'every' => 3}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it "should consider different 'every' as different triggers" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
         desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 1}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
         trigger = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '01:30', 'every' => 1}
 
         provider.should be_triggers_same(trigger, trigger)
       end
     end
 
     describe 'comparing one-time triggers' do
       it "should consider different 'start_dates' as different triggers" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30'}
         desired = {'schedule' => 'daily', 'start_date' => '2012-09-12', 'start_time' => '15:30'}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
         current = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:30'}
         desired = {'schedule' => 'daily', 'start_date' => '2011-09-12', 'start_time' => '15:31'}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in date formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30'}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-9-12',  'start_time' => '15:30'}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in time formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '1:30'}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '01:30'}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
         trigger = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '01:30'}
 
         provider.should be_triggers_same(trigger, trigger)
       end
     end
 
     describe 'comparing monthly date-based triggers' do
       it "should consider 'desired' triggers not specifying 'months' to have the same value as the 'current' trigger" do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [3], 'on' => [1,'last']}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'on' => [1, 'last']}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_dates' as different triggers" do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-10-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '22:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in date formatting to be different triggers' do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-9-12',  'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in time formatting to be different triggers' do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '5:30',  'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '05:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it "should consider different 'months' as different triggers" do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1],    'on' => [1, 3, 5, 7]}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'on' as different triggers" do
         current = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
         desired = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 5, 7]}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
         trigger = {'schedule' => 'monthly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'months' => [1, 2], 'on' => [1, 3, 5, 7]}
 
         provider.should be_triggers_same(trigger, trigger)
       end
     end
 
     describe 'comparing monthly day-of-week-based triggers' do
       it "should consider 'desired' triggers not specifying 'months' to have the same value as the 'current' trigger" do
         current = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
         desired = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
         provider.should be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_dates' as different triggers" do
         current = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
         desired = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-10-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
         current = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
         desired = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '22:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'months' as different triggers" do
         current = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
         desired = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3, 5, 7, 9],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'which_occurrence' as different triggers" do
         current = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
         desired = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'last',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'day_of_week' as different triggers" do
         current = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
         desired = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['fri']
         }
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
         trigger = {
           'schedule'         => 'monthly',
           'start_date'       => '2011-09-12',
           'start_time'       => '15:30',
           'months'           => [3],
           'which_occurrence' => 'first',
           'day_of_week'      => ['mon', 'tues', 'sat']
         }
 
         provider.should be_triggers_same(trigger, trigger)
       end
     end
 
     describe 'comparing weekly triggers' do
       it "should consider 'desired' triggers not specifying 'day_of_week' to have the same value as the 'current' trigger" do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_dates' as different triggers" do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-10-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'start_times' as different triggers" do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '22:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in date formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-9-12',  'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it 'should not consider differences in time formatting to be different triggers' do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '1:30',  'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '01:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
         provider.should be_triggers_same(current, desired)
       end
 
       it "should consider different 'every' as different triggers" do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 1, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it "should consider different 'day_of_week' as different triggers" do
         current = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
         desired = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['fri']}
 
         provider.should_not be_triggers_same(current, desired)
       end
 
       it 'should consider triggers that are the same as being the same' do
         trigger = {'schedule' => 'weekly', 'start_date' => '2011-09-12', 'start_time' => '15:30', 'every' => 3, 'day_of_week' => ['mon', 'wed', 'fri']}
 
         provider.should be_triggers_same(trigger, trigger)
       end
     end
   end
 
   describe '#normalized_date' do
     it 'should format the date without leading zeros' do
       described_class.normalized_date('2011-01-01').should == '2011-1-1'
     end
   end
 
   describe '#normalized_time' do
     it 'should format the time as {24h}:{minutes}' do
       described_class.normalized_time('8:37 PM').should == '20:37'
     end
   end
 
   describe '#translate_hash_to_trigger' do
     before :each do
       @puppet_trigger = {
         'start_date' => '2011-1-1',
         'start_time' => '01:10'
       }
     end
     let(:provider) { described_class.new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe') }
     let(:trigger)  { provider.translate_hash_to_trigger(@puppet_trigger) }
 
     describe 'when given a one-time trigger' do
       before :each do
         @puppet_trigger['schedule'] = 'once'
       end
 
       it 'should set the trigger_type to Win32::TaskScheduler::ONCE' do
         trigger['trigger_type'].should == Win32::TaskScheduler::ONCE
       end
 
       it 'should not set a type' do
         trigger.should_not be_has_key('type')
       end
 
       it "should require 'start_date'" do
         @puppet_trigger.delete('start_date')
 
         expect { trigger }.to raise_error(
           Puppet::Error,
           /Must specify 'start_date' when defining a one-time trigger/
         )
       end
 
       it "should require 'start_time'" do
         @puppet_trigger.delete('start_time')
 
         expect { trigger }.to raise_error(
           Puppet::Error,
           /Must specify 'start_time' when defining a trigger/
         )
       end
 
       it_behaves_like "a trigger that handles start_date and start_time" do
         let(:trigger_hash) {{'schedule' => 'once' }}
       end
     end
 
     describe 'when given a daily trigger' do
       before :each do
         @puppet_trigger['schedule'] = 'daily'
       end
 
       it "should default 'every' to 1" do
         trigger['type']['days_interval'].should == 1
       end
 
       it "should use the specified value for 'every'" do
         @puppet_trigger['every'] = 5
 
         trigger['type']['days_interval'].should == 5
       end
 
       it "should default 'start_date' to 'today'" do
         @puppet_trigger.delete('start_date')
         today = Time.now
 
         trigger['start_year'].should == today.year
         trigger['start_month'].should == today.month
         trigger['start_day'].should == today.day
       end
 
       it_behaves_like "a trigger that handles start_date and start_time" do
         let(:trigger_hash) {{'schedule' => 'daily', 'every' => 1}}
       end
     end
 
     describe 'when given a weekly trigger' do
       before :each do
         @puppet_trigger['schedule'] = 'weekly'
       end
 
       it "should default 'every' to 1" do
         trigger['type']['weeks_interval'].should == 1
       end
 
       it "should use the specified value for 'every'" do
         @puppet_trigger['every'] = 4
 
         trigger['type']['weeks_interval'].should == 4
       end
 
       it "should default 'day_of_week' to be every day of the week" do
         trigger['type']['days_of_week'].should == Win32::TaskScheduler::MONDAY    |
                                                   Win32::TaskScheduler::TUESDAY   |
                                                   Win32::TaskScheduler::WEDNESDAY |
                                                   Win32::TaskScheduler::THURSDAY  |
                                                   Win32::TaskScheduler::FRIDAY    |
                                                   Win32::TaskScheduler::SATURDAY  |
                                                   Win32::TaskScheduler::SUNDAY
       end
 
       it "should use the specified value for 'day_of_week'" do
         @puppet_trigger['day_of_week'] = ['mon', 'wed', 'fri']
 
         trigger['type']['days_of_week'].should == Win32::TaskScheduler::MONDAY    |
                                                   Win32::TaskScheduler::WEDNESDAY |
                                                   Win32::TaskScheduler::FRIDAY
       end
 
       it "should default 'start_date' to 'today'" do
         @puppet_trigger.delete('start_date')
         today = Time.now
 
         trigger['start_year'].should == today.year
         trigger['start_month'].should == today.month
         trigger['start_day'].should == today.day
       end
 
       it_behaves_like "a trigger that handles start_date and start_time" do
         let(:trigger_hash) {{'schedule' => 'weekly', 'every' => 1, 'day_of_week' => 'mon'}}
       end
     end
 
     shared_examples_for 'a monthly schedule' do
       it "should default 'months' to be every month" do
         trigger['type']['months'].should == Win32::TaskScheduler::JANUARY   |
                                             Win32::TaskScheduler::FEBRUARY  |
                                             Win32::TaskScheduler::MARCH     |
                                             Win32::TaskScheduler::APRIL     |
                                             Win32::TaskScheduler::MAY       |
                                             Win32::TaskScheduler::JUNE      |
                                             Win32::TaskScheduler::JULY      |
                                             Win32::TaskScheduler::AUGUST    |
                                             Win32::TaskScheduler::SEPTEMBER |
                                             Win32::TaskScheduler::OCTOBER   |
                                             Win32::TaskScheduler::NOVEMBER  |
                                             Win32::TaskScheduler::DECEMBER
       end
 
       it "should use the specified value for 'months'" do
         @puppet_trigger['months'] = [2, 8]
 
         trigger['type']['months'].should == Win32::TaskScheduler::FEBRUARY  |
                                             Win32::TaskScheduler::AUGUST
       end
     end
 
     describe 'when given a monthly date-based trigger' do
       before :each do
         @puppet_trigger['schedule'] = 'monthly'
         @puppet_trigger['on']       = [7, 14]
       end
 
       it_behaves_like 'a monthly schedule'
 
       it "should not allow 'which_occurrence' to be specified" do
         @puppet_trigger['which_occurrence'] = 'first'
 
         expect {trigger}.to raise_error(
           Puppet::Error,
           /Neither 'day_of_week' nor 'which_occurrence' can be specified when creating a monthly date-based trigger/
         )
       end
 
       it "should not allow 'day_of_week' to be specified" do
         @puppet_trigger['day_of_week'] = 'mon'
 
         expect {trigger}.to raise_error(
           Puppet::Error,
           /Neither 'day_of_week' nor 'which_occurrence' can be specified when creating a monthly date-based trigger/
         )
       end
 
       it "should require 'on'" do
         @puppet_trigger.delete('on')
 
         expect {trigger}.to raise_error(
           Puppet::Error,
           /Don't know how to create a 'monthly' schedule with the options: schedule, start_date, start_time/
         )
       end
 
       it "should default 'start_date' to 'today'" do
         @puppet_trigger.delete('start_date')
         today = Time.now
 
         trigger['start_year'].should == today.year
         trigger['start_month'].should == today.month
         trigger['start_day'].should == today.day
       end
 
       it_behaves_like "a trigger that handles start_date and start_time" do
         let(:trigger_hash) {{'schedule' => 'monthly', 'months' => 1, 'on' => 1}}
       end
     end
 
     describe 'when given a monthly day-of-week-based trigger' do
       before :each do
         @puppet_trigger['schedule']         = 'monthly'
         @puppet_trigger['which_occurrence'] = 'first'
         @puppet_trigger['day_of_week']      = 'mon'
       end
 
       it_behaves_like 'a monthly schedule'
 
       it "should not allow 'on' to be specified" do
         @puppet_trigger['on'] = 15
 
         expect {trigger}.to raise_error(
           Puppet::Error,
           /Neither 'day_of_week' nor 'which_occurrence' can be specified when creating a monthly date-based trigger/
         )
       end
 
       it "should require 'which_occurrence'" do
         @puppet_trigger.delete('which_occurrence')
 
         expect {trigger}.to raise_error(
           Puppet::Error,
           /which_occurrence must be specified when creating a monthly day-of-week based trigger/
         )
       end
 
       it "should require 'day_of_week'" do
         @puppet_trigger.delete('day_of_week')
 
         expect {trigger}.to raise_error(
           Puppet::Error,
           /day_of_week must be specified when creating a monthly day-of-week based trigger/
         )
       end
 
       it "should default 'start_date' to 'today'" do
         @puppet_trigger.delete('start_date')
         today = Time.now
 
         trigger['start_year'].should == today.year
         trigger['start_month'].should == today.month
         trigger['start_day'].should == today.day
       end
 
       it_behaves_like "a trigger that handles start_date and start_time" do
         let(:trigger_hash) {{'schedule' => 'monthly', 'months' => 1, 'which_occurrence' => 'first', 'day_of_week' => 'mon'}}
       end
     end
   end
 
   describe '#validate_trigger' do
     let(:provider) { described_class.new(:name => 'Test Task', :command => 'C:\Windows\System32\notepad.exe') }
 
     it 'should succeed if all passed triggers translate from hashes to triggers' do
       triggers_to_validate = [
         {'schedule' => 'once',   'start_date' => '2011-09-13', 'start_time' => '13:50'},
         {'schedule' => 'weekly', 'start_date' => '2011-09-13', 'start_time' => '13:50', 'day_of_week' => 'mon'}
       ]
 
       provider.validate_trigger(triggers_to_validate).should == true
     end
 
     it 'should use the exception from translate_hash_to_trigger when it fails' do
       triggers_to_validate = [
         {'schedule' => 'once', 'start_date' => '2011-09-13', 'start_time' => '13:50'},
         {'schedule' => 'monthly', 'this is invalid' => true}
       ]
 
       expect {provider.validate_trigger(triggers_to_validate)}.to raise_error(
         Puppet::Error,
         /#{Regexp.escape("Unknown trigger option(s): ['this is invalid']")}/
       )
     end
   end
 
   describe '#flush' do
     let(:resource) do
       Puppet::Type.type(:scheduled_task).new(
         :name    => 'Test Task',
         :command => 'C:\Windows\System32\notepad.exe',
         :ensure  => @ensure
       )
     end
 
     before :each do
       @mock_task = mock
       @mock_task.responds_like(Win32::TaskScheduler.new)
       @mock_task.stubs(:exists?).returns(true)
       @mock_task.stubs(:activate)
       Win32::TaskScheduler.stubs(:new).returns(@mock_task)
 
       @command = 'C:\Windows\System32\notepad.exe'
     end
 
     describe 'when :ensure is :present' do
       before :each do
         @ensure = :present
       end
 
       it 'should save the task' do
         @mock_task.expects(:save)
 
         resource.provider.flush
       end
 
       it 'should fail if the command is not specified' do
         resource = Puppet::Type.type(:scheduled_task).new(
           :name    => 'Test Task',
           :ensure  => @ensure
         )
 
         expect { resource.provider.flush }.to raise_error(
           Puppet::Error,
           'Parameter command is required.'
         )
       end
     end
 
     describe 'when :ensure is :absent' do
       before :each do
         @ensure = :absent
         @mock_task.stubs(:activate)
       end
 
       it 'should not save the task if :ensure is :absent' do
         @mock_task.expects(:save).never
 
         resource.provider.flush
       end
 
       it 'should not fail if the command is not specified' do
         @mock_task.stubs(:save)
 
         resource = Puppet::Type.type(:scheduled_task).new(
           :name    => 'Test Task',
           :ensure  => @ensure
         )
 
         resource.provider.flush
       end
     end
   end
 
   describe 'property setter methods' do
     let(:resource) do
       Puppet::Type.type(:scheduled_task).new(
         :name    => 'Test Task',
         :command => 'C:\dummy_task.exe'
       )
     end
 
     before :each do
         @mock_task = mock
         @mock_task.responds_like(Win32::TaskScheduler.new)
         @mock_task.stubs(:exists?).returns(true)
         @mock_task.stubs(:activate)
         Win32::TaskScheduler.stubs(:new).returns(@mock_task)
     end
 
     describe '#command=' do
       it 'should set the application_name on the task' do
         @mock_task.expects(:application_name=).with('C:\Windows\System32\notepad.exe')
 
         resource.provider.command = 'C:\Windows\System32\notepad.exe'
       end
     end
 
     describe '#arguments=' do
       it 'should set the parameters on the task' do
         @mock_task.expects(:parameters=).with(['/some /arguments /here'])
 
         resource.provider.arguments = ['/some /arguments /here']
       end
     end
 
     describe '#working_dir=' do
       it 'should set the working_directory on the task' do
         @mock_task.expects(:working_directory=).with('C:\Windows\System32')
 
         resource.provider.working_dir = 'C:\Windows\System32'
       end
     end
 
     describe '#enabled=' do
       it 'should set the disabled flag if the task should be disabled' do
+        pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
         @mock_task.stubs(:flags).returns(0)
         @mock_task.expects(:flags=).with(Win32::TaskScheduler::DISABLED)
 
         resource.provider.enabled = :false
       end
 
       it 'should clear the disabled flag if the task should be enabled' do
+        pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
         @mock_task.stubs(:flags).returns(Win32::TaskScheduler::DISABLED)
         @mock_task.expects(:flags=).with(0)
 
         resource.provider.enabled = :true
       end
     end
 
     describe '#trigger=' do
       let(:resource) do
         Puppet::Type.type(:scheduled_task).new(
           :name    => 'Test Task',
           :command => 'C:\Windows\System32\notepad.exe',
           :trigger => @trigger
         )
       end
 
       before :each do
         @mock_task = mock
         @mock_task.responds_like(Win32::TaskScheduler.new)
         @mock_task.stubs(:exists?).returns(true)
         @mock_task.stubs(:activate)
         Win32::TaskScheduler.stubs(:new).returns(@mock_task)
       end
 
       it 'should not consider all duplicate current triggers in sync with a single desired trigger' do
         @trigger = {'schedule' => 'once', 'start_date' => '2011-09-15', 'start_time' => '15:10'}
         current_triggers = [
           {'schedule' => 'once', 'start_date' => '2011-09-15', 'start_time' => '15:10', 'index' => 0},
           {'schedule' => 'once', 'start_date' => '2011-09-15', 'start_time' => '15:10', 'index' => 1},
           {'schedule' => 'once', 'start_date' => '2011-09-15', 'start_time' => '15:10', 'index' => 2},
         ]
         resource.provider.stubs(:trigger).returns(current_triggers)
         @mock_task.expects(:delete_trigger).with(1)
         @mock_task.expects(:delete_trigger).with(2)
 
         resource.provider.trigger = @trigger
       end
 
       it 'should remove triggers not defined in the resource' do
         @trigger = {'schedule' => 'once', 'start_date' => '2011-09-15', 'start_time' => '15:10'}
         current_triggers = [
           {'schedule' => 'once', 'start_date' => '2011-09-15', 'start_time' => '15:10', 'index' => 0},
           {'schedule' => 'once', 'start_date' => '2012-09-15', 'start_time' => '15:10', 'index' => 1},
           {'schedule' => 'once', 'start_date' => '2013-09-15', 'start_time' => '15:10', 'index' => 2},
         ]
         resource.provider.stubs(:trigger).returns(current_triggers)
         @mock_task.expects(:delete_trigger).with(1)
         @mock_task.expects(:delete_trigger).with(2)
 
         resource.provider.trigger = @trigger
       end
 
       it 'should add triggers defined in the resource, but not found on the system' do
         @trigger = [
           {'schedule' => 'once', 'start_date' => '2011-09-15', 'start_time' => '15:10'},
           {'schedule' => 'once', 'start_date' => '2012-09-15', 'start_time' => '15:10'},
           {'schedule' => 'once', 'start_date' => '2013-09-15', 'start_time' => '15:10'},
         ]
         current_triggers = [
           {'schedule' => 'once', 'start_date' => '2011-09-15', 'start_time' => '15:10', 'index' => 0},
         ]
         resource.provider.stubs(:trigger).returns(current_triggers)
         @mock_task.expects(:trigger=).with(resource.provider.translate_hash_to_trigger(@trigger[1]))
         @mock_task.expects(:trigger=).with(resource.provider.translate_hash_to_trigger(@trigger[2]))
 
         resource.provider.trigger = @trigger
       end
     end
 
     describe '#user=', :if => Puppet.features.microsoft_windows? do
       before :each do
         @mock_task = mock
         @mock_task.responds_like(Win32::TaskScheduler.new)
         @mock_task.stubs(:exists?).returns(true)
         @mock_task.stubs(:activate)
         Win32::TaskScheduler.stubs(:new).returns(@mock_task)
       end
 
       it 'should use nil for user and password when setting the user to the SYSTEM account' do
         Puppet::Util::Windows::SID.stubs(:name_to_sid).with('system').returns('SYSTEM SID')
 
         resource = Puppet::Type.type(:scheduled_task).new(
           :name    => 'Test Task',
           :command => 'C:\dummy_task.exe',
           :user    => 'system'
         )
 
         @mock_task.expects(:set_account_information).with(nil, nil)
 
         resource.provider.user = 'system'
       end
 
       it 'should use the specified user and password when setting the user to anything other than SYSTEM' do
         Puppet::Util::Windows::SID.stubs(:name_to_sid).with('my_user_name').returns('SID A')
 
         resource = Puppet::Type.type(:scheduled_task).new(
           :name     => 'Test Task',
           :command  => 'C:\dummy_task.exe',
           :user     => 'my_user_name',
           :password => 'my password'
         )
 
         @mock_task.expects(:set_account_information).with('my_user_name', 'my password')
 
         resource.provider.user = 'my_user_name'
       end
     end
   end
 
   describe '#create' do
     let(:resource) do
       Puppet::Type.type(:scheduled_task).new(
         :name        => 'Test Task',
         :enabled     => @enabled,
         :command     => @command,
         :arguments   => @arguments,
         :working_dir => @working_dir,
         :trigger     => { 'schedule' => 'once', 'start_date' => '2011-09-27', 'start_time' => '17:00' }
       )
     end
 
     before :each do
       @enabled     = :true
       @command     = 'C:\Windows\System32\notepad.exe'
       @arguments   = '/a /list /of /arguments'
       @working_dir = 'C:\Windows\Some\Directory'
 
       @mock_task = mock
       @mock_task.responds_like(Win32::TaskScheduler.new)
       @mock_task.stubs(:exists?).returns(true)
       @mock_task.stubs(:activate)
       @mock_task.stubs(:application_name=)
       @mock_task.stubs(:parameters=)
       @mock_task.stubs(:working_directory=)
       @mock_task.stubs(:set_account_information)
       @mock_task.stubs(:flags)
       @mock_task.stubs(:flags=)
       @mock_task.stubs(:trigger_count).returns(0)
       @mock_task.stubs(:trigger=)
       @mock_task.stubs(:save)
       Win32::TaskScheduler.stubs(:new).returns(@mock_task)
 
       described_class.any_instance.stubs(:sync_triggers)
     end
 
     it 'should set the command' do
+      pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
       resource.provider.expects(:command=).with(@command)
 
       resource.provider.create
     end
 
     it 'should set the arguments' do
+      pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
       resource.provider.expects(:arguments=).with(@arguments)
 
       resource.provider.create
     end
 
     it 'should set the working_dir' do
+      pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
       resource.provider.expects(:working_dir=).with(@working_dir)
 
       resource.provider.create
     end
 
     it "should set the user" do
+      pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
       resource.provider.expects(:user=).with(:system)
 
       resource.provider.create
     end
 
     it 'should set the enabled property' do
+      pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
       resource.provider.expects(:enabled=)
 
       resource.provider.create
     end
 
     it 'should sync triggers' do
+      pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
       resource.provider.expects(:trigger=)
 
       resource.provider.create
     end
   end
 end
diff --git a/spec/unit/util/log_spec.rb b/spec/unit/util/log_spec.rb
index bc6ecfcf0..ac4a700c5 100755
--- a/spec/unit/util/log_spec.rb
+++ b/spec/unit/util/log_spec.rb
@@ -1,378 +1,379 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/log'
 
 describe Puppet::Util::Log do
   include PuppetSpec::Files
 
   def log_notice(message)
     Puppet::Util::Log.new(:level => :notice, :message => message)
   end
 
   it "should write a given message to the specified destination" do
     arraydest = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
     Puppet::Util::Log.new(:level => :notice, :message => "foo")
     message = arraydest.last.message
     message.should == "foo"
   end
 
   describe ".setup_default" do
     it "should default to :syslog" do
       Puppet.features.stubs(:syslog?).returns(true)
       Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
       Puppet::Util::Log.setup_default
     end
 
     it "should fall back to :eventlog" do
       Puppet.features.stubs(:syslog?).returns(false)
       Puppet.features.stubs(:eventlog?).returns(true)
       Puppet::Util::Log.expects(:newdestination).with(:eventlog)
 
       Puppet::Util::Log.setup_default
     end
 
     it "should fall back to :file" do
       Puppet.features.stubs(:syslog?).returns(false)
       Puppet.features.stubs(:eventlog?).returns(false)
       Puppet::Util::Log.expects(:newdestination).with(Puppet[:puppetdlog])
 
       Puppet::Util::Log.setup_default
     end
   end
 
   describe "#with_destination" do
     it "does nothing when nested" do
       logs = []
       destination = Puppet::Test::LogCollector.new(logs)
       Puppet::Util::Log.with_destination(destination) do
         Puppet::Util::Log.with_destination(destination) do
           log_notice("Inner block")
         end
 
         log_notice("Outer block")
       end
 
       log_notice("Outside")
 
       expect(logs.collect(&:message)).to include("Inner block", "Outer block")
       expect(logs.collect(&:message)).not_to include("Outside")
     end
 
     it "logs when called a second time" do
       logs = []
       destination = Puppet::Test::LogCollector.new(logs)
 
       Puppet::Util::Log.with_destination(destination) do
         log_notice("First block")
       end
 
       log_notice("Between blocks")
 
       Puppet::Util::Log.with_destination(destination) do
         log_notice("Second block")
       end
 
       expect(logs.collect(&:message)).to include("First block", "Second block")
       expect(logs.collect(&:message)).not_to include("Between blocks")
     end
 
     it "doesn't close the destination if already set manually" do
       logs = []
       destination = Puppet::Test::LogCollector.new(logs)
 
       Puppet::Util::Log.newdestination(destination)
       Puppet::Util::Log.with_destination(destination) do
         log_notice "Inner block"
       end
 
       log_notice "Outer block"
       Puppet::Util::Log.close(destination)
 
       expect(logs.collect(&:message)).to include("Inner block", "Outer block")
     end
   end
   describe Puppet::Util::Log::DestConsole do
     before do
       @console = Puppet::Util::Log::DestConsole.new
       @console.stubs(:console_has_color?).returns(true)
     end
 
     it "should colorize if Puppet[:color] is :ansi" do
       Puppet[:color] = :ansi
 
       @console.colorize(:alert, "abc").should == "\e[0;31mabc\e[0m"
     end
 
     it "should colorize if Puppet[:color] is 'yes'" do
       Puppet[:color] = "yes"
 
       @console.colorize(:alert, "abc").should == "\e[0;31mabc\e[0m"
     end
 
     it "should htmlize if Puppet[:color] is :html" do
       Puppet[:color] = :html
 
       @console.colorize(:alert, "abc").should == "<span style=\"color: #FFA0A0\">abc</span>"
     end
 
     it "should do nothing if Puppet[:color] is false" do
       Puppet[:color] = false
 
       @console.colorize(:alert, "abc").should == "abc"
     end
 
     it "should do nothing if Puppet[:color] is invalid" do
       Puppet[:color] = "invalid option"
 
       @console.colorize(:alert, "abc").should == "abc"
     end
   end
 
   describe Puppet::Util::Log::DestSyslog do
     before do
       @syslog = Puppet::Util::Log::DestSyslog.new
     end
   end
 
   describe Puppet::Util::Log::DestEventlog, :if => Puppet.features.eventlog? do
     before :each do
       Win32::EventLog.stubs(:open).returns(mock 'mylog')
       Win32::EventLog.stubs(:report_event)
       Win32::EventLog.stubs(:close)
       Puppet.features.stubs(:eventlog?).returns(true)
     end
 
     it "should restrict its suitability" do
       Puppet.features.expects(:eventlog?).returns(false)
 
       Puppet::Util::Log::DestEventlog.suitable?('whatever').should == false
     end
 
     it "should open the 'Application' event log" do
       Win32::EventLog.expects(:open).with('Application')
 
       Puppet::Util::Log.newdestination(:eventlog)
     end
 
     it "should close the event log" do
       log = mock('myeventlog')
       log.expects(:close)
       Win32::EventLog.expects(:open).returns(log)
 
       Puppet::Util::Log.newdestination(:eventlog)
       Puppet::Util::Log.close(:eventlog)
     end
 
     it "should handle each puppet log level" do
+      pending('porting to windows ruby2') if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^2\./
       log = Puppet::Util::Log::DestEventlog.new
 
       Puppet::Util::Log.eachlevel do |level|
         log.to_native(level).should be_is_a(Array)
       end
     end
   end
 
   describe "instances" do
     before do
       Puppet::Util::Log.stubs(:newmessage)
     end
 
     [:level, :message, :time, :remote].each do |attr|
       it "should have a #{attr} attribute" do
         log = Puppet::Util::Log.new :level => :notice, :message => "A test message"
         log.should respond_to(attr)
         log.should respond_to(attr.to_s + "=")
       end
     end
 
     it "should fail if created without a level" do
       lambda { Puppet::Util::Log.new(:message => "A test message") }.should raise_error(ArgumentError)
     end
 
     it "should fail if created without a message" do
       lambda { Puppet::Util::Log.new(:level => :notice) }.should raise_error(ArgumentError)
     end
 
     it "should make available the level passed in at initialization" do
       Puppet::Util::Log.new(:level => :notice, :message => "A test message").level.should == :notice
     end
 
     it "should make available the message passed in at initialization" do
       Puppet::Util::Log.new(:level => :notice, :message => "A test message").message.should == "A test message"
     end
 
     # LAK:NOTE I don't know why this behavior is here, I'm just testing what's in the code,
     # at least at first.
     it "should always convert messages to strings" do
       Puppet::Util::Log.new(:level => :notice, :message => :foo).message.should == "foo"
     end
 
     it "should flush the log queue when the first destination is specified" do
       Puppet::Util::Log.close_all
       Puppet::Util::Log.expects(:flushqueue)
       Puppet::Util::Log.newdestination(:console)
     end
 
     it "should convert the level to a symbol if it's passed in as a string" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).level.should == :notice
     end
 
     it "should fail if the level is not a symbol or string" do
       lambda { Puppet::Util::Log.new(:level => 50, :message => :foo) }.should raise_error(ArgumentError)
     end
 
     it "should fail if the provided level is not valid" do
       Puppet::Util::Log.expects(:validlevel?).with(:notice).returns false
       lambda { Puppet::Util::Log.new(:level => :notice, :message => :foo) }.should raise_error(ArgumentError)
     end
 
     it "should set its time to the initialization time" do
       time = mock 'time'
       Time.expects(:now).returns time
       Puppet::Util::Log.new(:level => "notice", :message => :foo).time.should equal(time)
     end
 
     it "should make available any passed-in tags" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :tags => %w{foo bar})
       log.tags.should be_include("foo")
       log.tags.should be_include("bar")
     end
 
     it "should use a passed-in source" do
       Puppet::Util::Log.any_instance.expects(:source=).with "foo"
       Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => "foo")
     end
 
     [:file, :line].each do |attr|
       it "should use #{attr} if provided" do
         Puppet::Util::Log.any_instance.expects(attr.to_s + "=").with "foo"
         Puppet::Util::Log.new(:level => "notice", :message => :foo, attr => "foo")
       end
     end
 
     it "should default to 'Puppet' as its source" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).source.should == "Puppet"
     end
 
     it "should register itself with Log" do
       Puppet::Util::Log.expects(:newmessage)
       Puppet::Util::Log.new(:level => "notice", :message => :foo)
     end
 
     it "should update Log autoflush when Puppet[:autoflush] is set" do
       Puppet::Util::Log.expects(:autoflush=).once.with(true)
       Puppet[:autoflush] = true
     end
 
     it "should have a method for determining if a tag is present" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).should respond_to(:tagged?)
     end
 
     it "should match a tag if any of the tags are equivalent to the passed tag as a string" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo, :tags => %w{one two}).should be_tagged(:one)
     end
 
     it "should tag itself with its log level" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).should be_tagged(:notice)
     end
 
     it "should return its message when converted to a string" do
       Puppet::Util::Log.new(:level => "notice", :message => :foo).to_s.should == "foo"
     end
 
     it "should include its time, source, level, and message when prepared for reporting" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
       report = log.to_report
       report.should be_include("notice")
       report.should be_include("foo")
       report.should be_include(log.source)
       report.should be_include(log.time.to_s)
     end
 
     it "should not create unsuitable log destinations" do
       Puppet.features.stubs(:syslog?).returns(false)
 
       Puppet::Util::Log::DestSyslog.expects(:suitable?)
       Puppet::Util::Log::DestSyslog.expects(:new).never
 
       Puppet::Util::Log.newdestination(:syslog)
     end
 
     describe "when setting the source as a RAL object" do
       let(:path) { File.expand_path('/foo/bar') }
 
       it "should tag itself with any tags the source has" do
         source = Puppet::Type.type(:file).new :path => path
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
         source.tags.each do |tag|
           log.tags.should be_include(tag)
         end
       end
 
       it "should set the source to 'path', when available" do
         source = Puppet::Type.type(:file).new :path => path
         source.tags = ["tag", "tag2"]
 
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
         log.expects(:tag).with("file")
         log.expects(:tag).with("tag")
         log.expects(:tag).with("tag2")
 
         log.source = source
 
         log.source.should == "/File[#{path}]"
       end
 
       it "should copy over any file and line information" do
         source = Puppet::Type.type(:file).new :path => path
         source.file = "/my/file"
         source.line = 50
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
         log.line.should == 50
         log.file.should == "/my/file"
       end
     end
 
     describe "when setting the source as a non-RAL object" do
       it "should not try to copy over file, version, line, or tag information" do
         source = mock
         source.expects(:file).never
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
       end
     end
   end
 
   describe "to_yaml" do
     it "should not include the @version attribute" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :version => 100)
       log.to_yaml_properties.should_not include('@version')
     end
 
     it "should include attributes @level, @message, @source, @tags, and @time" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :version => 100)
       log.to_yaml_properties.should =~ [:@level, :@message, :@source, :@tags, :@time]
     end
 
     it "should include attributes @file and @line if specified" do
       log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :file => "foo", :line => 35)
       log.to_yaml_properties.should include(:@file)
       log.to_yaml_properties.should include(:@line)
     end
   end
 
   it "should round trip through pson" do
     log = Puppet::Util::Log.new(:level => 'notice', :message => 'hooray', :file => 'thefile', :line => 1729, :source => 'specs', :tags => ['a', 'b', 'c'])
     tripped = Puppet::Util::Log.from_data_hash(PSON.parse(log.to_pson))
 
     tripped.file.should == log.file
     tripped.line.should == log.line
     tripped.level.should == log.level
     tripped.message.should == log.message
     tripped.source.should == log.source
     tripped.tags.should == log.tags
     tripped.time.should == log.time
   end
 end