diff --git a/lib/puppet/indirector/exec.rb b/lib/puppet/indirector/exec.rb
index fa789442b..4683eda0f 100644
--- a/lib/puppet/indirector/exec.rb
+++ b/lib/puppet/indirector/exec.rb
@@ -1,49 +1,48 @@
 require 'puppet/indirector/terminus'
 require 'puppet/util'
 
 class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
   # Look for external node definitions.
   def find(request)
     # Run the command.
     unless output = query(request.key)
       return nil
     end
 
     # Translate the output to ruby.
     output
   end
 
   private
 
   # Proxy the execution, so it's easier to test.
   def execute(command)
     Puppet::Util.execute(command)
   end
 
   # Call the external command and see if it returns our output.
   def query(name)
     external_command = command
 
     # Make sure it's an arry
     raise Puppet::DevError, "Exec commands must be an array" unless external_command.is_a?(Array)
 
     # Make sure it's fully qualified.
     raise ArgumentError, "You must set the exec parameter to a fully qualified command" unless external_command[0][0] == File::SEPARATOR[0]
 
     # Add our name to it.
     external_command << name
     begin
       output = execute(external_command)
     rescue Puppet::ExecutionFailure => detail
-      Puppet.err "Failed to find #{name} via exec: #{detail}"
-      return nil
+      raise Puppet::Error, "Failed to find #{name} via exec: #{detail}"
     end
 
     if output =~ /\A\s*\Z/ # all whitespace
       Puppet.debug "Empty response for #{name} from exec #{self.name} terminus"
       return nil
     else
       return output
     end
   end
 end
diff --git a/lib/puppet/parameter.rb b/lib/puppet/parameter.rb
index ff7cab22b..29d60fc66 100644
--- a/lib/puppet/parameter.rb
+++ b/lib/puppet/parameter.rb
@@ -1,302 +1,304 @@
 require 'puppet/util/methodhelper'
 require 'puppet/util/log_paths'
 require 'puppet/util/logging'
 require 'puppet/util/docs'
 require 'puppet/util/cacher'
 
 class Puppet::Parameter
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::LogPaths
   include Puppet::Util::Logging
   include Puppet::Util::MethodHelper
   include Puppet::Util::Cacher
 
   require 'puppet/parameter/value_collection'
 
   class << self
     include Puppet::Util
     include Puppet::Util::Docs
     attr_reader :validater, :munger, :name, :default, :required_features, :value_collection
     attr_accessor :metaparam
 
     # Define the default value for a given parameter or parameter.  This
     # means that 'nil' is an invalid default value.  This defines
     # the 'default' instance method.
     def defaultto(value = nil, &block)
       if block
         define_method(:default, &block)
       else
         if value.nil?
           raise Puppet::DevError,
             "Either a default value or block must be provided"
         end
         define_method(:default) do value end
       end
     end
 
     # Return a documentation string.  If there are valid values,
     # then tack them onto the string.
     def doc
       @doc ||= ""
 
       unless defined?(@addeddocvals)
         @doc += value_collection.doc
 
         if f = self.required_features
           @doc += "  Requires features #{f.flatten.collect { |f| f.to_s }.join(" ")}."
         end
         @addeddocvals = true
       end
 
       @doc
     end
 
     def nodefault
       undef_method :default if public_method_defined? :default
     end
 
     # Store documentation for this parameter.
     def desc(str)
       @doc = str
     end
 
     def initvars
       @value_collection = ValueCollection.new
     end
 
     # This is how we munge the value.  Basically, this is our
     # opportunity to convert the value from one form into another.
     def munge(&block)
       # I need to wrap the unsafe version in begin/rescue parameterments,
       # but if I directly call the block then it gets bound to the
       # class's context, not the instance's, thus the two methods,
       # instead of just one.
       define_method(:unsafe_munge, &block)
     end
 
     # Does the parameter supports reverse munge?
     # This will be called when something wants to access the parameter
     # in a canonical form different to what the storage form is.
     def unmunge(&block)
       define_method(:unmunge, &block)
     end
 
     # Mark whether we're the namevar.
     def isnamevar
       @isnamevar = true
       @required = true
     end
 
     # Is this parameter the namevar?  Defaults to false.
     def isnamevar?
       @isnamevar
     end
 
     # This parameter is required.
     def isrequired
       @required = true
     end
 
     # Specify features that are required for this parameter to work.
     def required_features=(*args)
       @required_features = args.flatten.collect { |a| a.to_s.downcase.intern }
     end
 
     # Is this parameter required?  Defaults to false.
     def required?
       @required
     end
 
     # Verify that we got a good value
     def validate(&block)
       define_method(:unsafe_validate, &block)
     end
 
     # Define a new value for our parameter.
     def newvalues(*names)
       @value_collection.newvalues(*names)
     end
 
     def aliasvalue(name, other)
       @value_collection.aliasvalue(name, other)
     end
   end
 
   # Just a simple method to proxy instance methods to class methods
   def self.proxymethods(*values)
     values.each { |val|
       define_method(val) do
         self.class.send(val)
       end
     }
   end
 
   # And then define one of these proxies for each method in our
   # ParamHandler class.
   proxymethods("required?", "isnamevar?")
 
   attr_accessor :resource
   # LAK 2007-05-09: Keep the @parent around for backward compatibility.
   attr_accessor :parent
 
   [:line, :file, :version].each do |param|
     define_method(param) do
       resource.send(param)
     end
   end
 
   def devfail(msg)
     self.fail(Puppet::DevError, msg)
   end
 
   def expirer
     resource.catalog
   end
 
   def fail(*args)
     type = nil
     if args[0].is_a?(Class)
       type = args.shift
     else
       type = Puppet::Error
     end
 
     error = type.new(args.join(" "))
 
     error.line = @resource.line if @resource and @resource.line
 
     error.file = @resource.file if @resource and @resource.file
 
     raise error
   end
 
   # Basic parameter initialization.
   def initialize(options = {})
     options = symbolize_options(options)
     if resource = options[:resource]
       self.resource = resource
       options.delete(:resource)
     else
       raise Puppet::DevError, "No resource set for #{self.class.name}"
     end
 
     set_options(options)
   end
 
   def log(msg)
     send_log(resource[:loglevel], msg)
   end
 
   # Is this parameter a metaparam?
   def metaparam?
     self.class.metaparam
   end
 
   # each parameter class must define the name method, and parameter
   # instances do not change that name this implicitly means that a given
   # object can only have one parameter instance of a given parameter
   # class
   def name
     self.class.name
   end
 
   # for testing whether we should actually do anything
   def noop
     @noop ||= false
     tmp = @noop || self.resource.noop || Puppet[:noop] || false
     #debug "noop is #{tmp}"
     tmp
   end
 
   # return the full path to us, for logging and rollback; not currently
   # used
   def pathbuilder
     if @resource
       return [@resource.pathbuilder, self.name]
     else
       return [self.name]
     end
   end
 
   # If the specified value is allowed, then munge appropriately.
   # If the developer uses a 'munge' hook, this method will get overridden.
   def unsafe_munge(value)
     self.class.value_collection.munge(value)
   end
 
   # no unmunge by default
   def unmunge(value)
     value
   end
 
   # A wrapper around our munging that makes sure we raise useful exceptions.
   def munge(value)
     begin
       ret = unsafe_munge(value)
     rescue Puppet::Error => detail
       Puppet.debug "Reraising #{detail}"
       raise
     rescue => detail
       raise Puppet::DevError, "Munging failed for value #{value.inspect} in class #{self.name}: #{detail}", detail.backtrace
     end
     ret
   end
 
   # Verify that the passed value is valid.
   # If the developer uses a 'validate' hook, this method will get overridden.
   def unsafe_validate(value)
     self.class.value_collection.validate(value)
   end
 
   # A protected validation method that only ever raises useful exceptions.
   def validate(value)
     begin
       unsafe_validate(value)
     rescue ArgumentError => detail
       fail detail.to_s
     rescue Puppet::Error, TypeError
       raise
     rescue => detail
       raise Puppet::DevError, "Validate method failed for class #{self.name}: #{detail}", detail.backtrace
     end
   end
 
   def remove
     @resource = nil
   end
 
   def value
     unmunge(@value) unless @value.nil?
   end
 
   # Store the value provided.  All of the checking should possibly be
   # late-binding (e.g., users might not exist when the value is assigned
   # but might when it is asked for).
   def value=(value)
     validate(value)
 
     @value = munge(value)
   end
 
   # Retrieve the resource's provider.  Some types don't have providers, in which
   # case we return the resource object itself.
   def provider
     @resource.provider
   end
 
   # The properties need to return tags so that logs correctly collect them.
   def tags
     unless defined?(@tags)
       @tags = []
       # This might not be true in testing
       @tags = @resource.tags if @resource.respond_to? :tags
       @tags << self.name.to_s
     end
     @tags
   end
 
   def to_s
     name.to_s
   end
 end
+
+require 'puppet/parameter/path'
diff --git a/lib/puppet/parameter/path.rb b/lib/puppet/parameter/path.rb
new file mode 100644
index 000000000..44886afd0
--- /dev/null
+++ b/lib/puppet/parameter/path.rb
@@ -0,0 +1,42 @@
+require 'puppet/parameter'
+
+class Puppet::Parameter::Path < Puppet::Parameter
+  def self.accept_arrays(bool = true)
+    @accept_arrays = !!bool
+  end
+  def self.arrays?
+    @accept_arrays
+  end
+
+  def validate_path(paths)
+    if paths.is_a?(Array) and ! self.class.arrays? then
+      fail "#{name} only accepts a single path, not an array of paths"
+    end
+
+    # We *always* support Unix path separators, as Win32 does now too.
+    absolute = "[/#{::Regexp.quote(::File::SEPARATOR)}]"
+    win32    = Puppet.features.microsoft_windows?
+
+    Array(paths).each do |path|
+      next if path =~ %r{^#{absolute}}
+      next if win32 and path =~ %r{^(?:[a-zA-Z]:)?#{absolute}}
+      fail("#{name} must be a fully qualified path")
+    end
+
+    paths
+  end
+
+  # This will be overridden if someone uses the validate option, which is why
+  # it just delegates to the other, useful, method.
+  def unsafe_validate(paths)
+    validate_path(paths)
+  end
+
+  # Likewise, this might be overridden, but by default...
+  def unsafe_munge(paths)
+    if paths.is_a?(Array) and ! self.class.arrays? then
+      fail "#{name} only accepts a single path, not an array of paths"
+    end
+    paths
+  end
+end
diff --git a/lib/puppet/provider/exec/posix.rb b/lib/puppet/provider/exec/posix.rb
new file mode 100644
index 000000000..92dbd8c98
--- /dev/null
+++ b/lib/puppet/provider/exec/posix.rb
@@ -0,0 +1,112 @@
+Puppet::Type.type(:exec).provide :posix do
+  include Puppet::Util::Execution
+
+  confine :feature => :posix
+  defaultfor :feature => :posix
+
+  desc "Execute external binaries directly, on POSIX systems.
+This does not pass through a shell, or perform any interpolation, but
+only directly calls the command with the arguments given."
+
+  def run(command, check = false)
+    output = nil
+    status = nil
+    dir = nil
+
+    checkexe(command)
+
+    if dir = resource[:cwd]
+      unless File.directory?(dir)
+        if check
+          dir = nil
+        else
+          self.fail "Working directory '#{dir}' does not exist"
+        end
+      end
+    end
+
+    dir ||= Dir.pwd
+
+    debug "Executing#{check ? " check": ""} '#{command}'"
+    begin
+      # Do our chdir
+      Dir.chdir(dir) do
+        environment = {}
+
+        environment[:PATH] = resource[:path].join(":") if resource[:path]
+
+        if envlist = resource[:environment]
+          envlist = [envlist] unless envlist.is_a? Array
+          envlist.each do |setting|
+            if setting =~ /^(\w+)=((.|\n)+)$/
+              env_name = $1
+              value = $2
+              if environment.include?(env_name) || environment.include?(env_name.to_sym)
+                warning "Overriding environment setting '#{env_name}' with '#{value}'"
+              end
+              environment[env_name] = value
+            else
+              warning "Cannot understand environment setting #{setting.inspect}"
+            end
+          end
+        end
+
+        withenv environment do
+          Timeout::timeout(resource[:timeout]) do
+            output, status = Puppet::Util::SUIDManager.
+              run_and_capture([command], resource[:user], resource[:group])
+          end
+          # The shell returns 127 if the command is missing.
+          if status.exitstatus == 127
+            raise ArgumentError, output
+          end
+        end
+      end
+    rescue Errno::ENOENT => detail
+      self.fail detail.to_s
+    end
+
+    return output, status
+  end
+
+  # Verify that we have the executable
+  def checkexe(command)
+    exe = extractexe(command)
+
+    if resource[:path]
+      if Puppet.features.posix? and !File.exists?(exe)
+        withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
+          exe = which(exe) || raise(ArgumentError,"Could not find command '#{exe}'")
+        end
+      elsif Puppet.features.microsoft_windows? and !File.exists?(exe)
+        resource[:path].each do |path|
+          [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
+            file = File.join(path, exe+extension)
+            return if File.exists?(file)
+          end
+        end
+      end
+    end
+
+    raise ArgumentError, "Could not find command '#{exe}'" unless File.exists?(exe)
+    unless File.executable?(exe)
+      raise ArgumentError,
+      "'#{exe}' is not executable"
+    end
+  end
+
+  def extractexe(command)
+    # easy case: command was quoted
+    if command =~ /^"([^"]+)"/
+      $1
+    else
+      command.split(/ /)[0]
+    end
+  end
+
+  def validatecmd(command)
+    exe = extractexe(command)
+    # if we're not fully qualified, require a path
+    self.fail "'#{command}' is not qualified and no path was specified. Please qualify the command or specify a path." if File.expand_path(exe) != exe and resource[:path].nil?
+  end
+end
diff --git a/lib/puppet/provider/exec/shell.rb b/lib/puppet/provider/exec/shell.rb
new file mode 100644
index 000000000..98f309e8f
--- /dev/null
+++ b/lib/puppet/provider/exec/shell.rb
@@ -0,0 +1,17 @@
+Puppet::Type.type(:exec).provide :shell, :parent => :posix do
+  include Puppet::Util::Execution
+
+  confine :feature => :posix
+
+  desc "Execute external binaries directly, on POSIX systems.
+passing through a shell so that shell built ins are available."
+
+  def run(command, check = false)
+    command = %Q{/bin/sh -c "#{command.gsub(/"/,'\"')}"}
+    super(command, check)
+  end
+
+  def validatecmd(command)
+    true
+  end
+end
diff --git a/lib/puppet/type/exec.rb b/lib/puppet/type/exec.rb
index ae579502a..773df2bb4 100755
--- a/lib/puppet/type/exec.rb
+++ b/lib/puppet/type/exec.rb
@@ -1,642 +1,507 @@
 module Puppet
   newtype(:exec) do
     include Puppet::Util::Execution
     require 'timeout'
 
     @doc = "Executes external commands.  It is critical that all commands
       executed using this mechanism can be run multiple times without
       harm, i.e., they are *idempotent*.  One useful way to create idempotent
       commands is to use the checks like `creates` to avoid running the
       command unless some condition is met.
 
       Note that you can restrict an `exec` to only run when it receives
       events by using the `refreshonly` parameter; this is a useful way to
       have your configuration respond to events with arbitrary commands.
 
       Note also that if an `exec` receives an event from another resource,
       it will get executed again (or execute the command specified in `refresh`, if there is one).
 
       There is a strong tendency to use `exec` to do whatever work Puppet
       can't already do; while this is obviously acceptable (and unavoidable)
       in the short term, it is highly recommended to migrate work from `exec`
       to native Puppet types as quickly as possible.  If you find that
       you are doing a lot of work with `exec`, please at least notify
       us at Puppet Labs what you are doing, and hopefully we can work with
       you to get a native resource type for the work you are doing.
-      
-      **Autorequires:** If Puppet is managing an exec's cwd or the executable file used in an exec's command, the exec resource will autorequire those files. If Puppet is managing the user that an exec should run as, the exec resource will autorequire that user."
 
-    require 'open3'
+      **Autorequires:** If Puppet is managing an exec's cwd or the executable file used in an exec's command, the exec resource will autorequire those files. If Puppet is managing the user that an exec should run as, the exec resource will autorequire that user."
 
     # Create a new check mechanism.  It's basically just a parameter that
     # provides one extra 'check' method.
-    def self.newcheck(name, &block)
+    def self.newcheck(name, options = {}, &block)
       @checks ||= {}
 
-      check = newparam(name, &block)
+      check = newparam(name, options, &block)
       @checks[name] = check
     end
 
     def self.checks
       @checks.keys
     end
 
     newproperty(:returns, :array_matching => :all, :event => :executed_command) do |property|
       include Puppet::Util::Execution
       munge do |value|
         value.to_s
       end
 
       def event_name
         :executed_command
       end
 
       defaultto "0"
 
       attr_reader :output
       desc "The expected return code(s).  An error will be returned if the
         executed command returns something else.  Defaults to 0. Can be
         specified as an array of acceptable return codes or a single value."
 
       # Make output a bit prettier
       def change_to_s(currentvalue, newvalue)
         "executed successfully"
       end
 
       # First verify that all of our checks pass.
       def retrieve
-        # Default to somethinng
-
-        if @resource.check
+        # We need to return :notrun to trigger evaluation; when that isn't
+        # true, we *LIE* about what happened and return a "success" for the
+        # value, which causes us to be treated as in_sync?, which means we
+        # don't actually execute anything.  I think. --daniel 2011-03-10
+        if @resource.check_all_attributes
           return :notrun
         else
           return self.should
         end
       end
 
       # Actually execute the command.
       def sync
         olddir = nil
 
         # We need a dir to change to, even if it's just the cwd
         dir = self.resource[:cwd] || Dir.pwd
 
         event = :executed_command
         tries = self.resource[:tries]
         try_sleep = self.resource[:try_sleep]
 
         begin
           tries.times do |try|
             # Only add debug messages for tries > 1 to reduce log spam.
             debug("Exec try #{try+1}/#{tries}") if tries > 1
-            @output, @status = @resource.run(self.resource[:command])
+            @output, @status = provider.run(self.resource[:command])
             break if self.should.include?(@status.exitstatus.to_s)
             if try_sleep > 0 and tries > 1
               debug("Sleeping for #{try_sleep} seconds between tries")
               sleep try_sleep
             end
           end
         rescue Timeout::Error
           self.fail "Command exceeded timeout" % value.inspect
         end
 
         if log = @resource[:logoutput]
           case log
           when :true
             log = @resource[:loglevel]
           when :on_failure
             unless self.should.include?(@status.exitstatus.to_s)
               log = @resource[:loglevel]
             else
               log = :false
             end
           end
           unless log == :false
             @output.split(/\n/).each { |line|
               self.send(log, line)
             }
           end
         end
 
         unless self.should.include?(@status.exitstatus.to_s)
           self.fail("#{self.resource[:command]} returned #{@status.exitstatus} instead of one of [#{self.should.join(",")}]")
         end
 
         event
       end
     end
 
     newparam(:command) do
       isnamevar
       desc "The actual command to execute.  Must either be fully qualified
         or a search path for the command must be provided.  If the command
         succeeds, any output produced will be logged at the instance's
         normal log level (usually `notice`), but if the command fails
         (meaning its return code does not match the specified code) then
         any output is logged at the `err` log level."
     end
 
     newparam(:path) do
       desc "The search path used for command execution.
         Commands must be fully qualified if no path is specified.  Paths
-        can be specified as an array or as a colon-separated list."
+        can be specified as an array or as a colon separated list."
 
       # Support both arrays and colon-separated fields.
       def value=(*values)
         @value = values.flatten.collect { |val|
           if val =~ /;/ # recognize semi-colon separated paths
             val.split(";")
           elsif val =~ /^\w:[^:]*$/ # heuristic to avoid splitting a driveletter away
             val
           else
             val.split(":")
           end
         }.flatten
       end
     end
 
     newparam(:user) do
       desc "The user to run the command as.  Note that if you
         use this then any error output is not currently captured.  This
         is because of a bug within Ruby.  If you are using Puppet to
         create this user, the exec will automatically require the user,
         as long as it is specified by name."
 
       # Most validation is handled by the SUIDManager class.
       validate do |user|
         self.fail "Only root can execute commands as other users" unless Puppet.features.root?
       end
     end
 
     newparam(:group) do
       desc "The group to run the command as.  This seems to work quite
         haphazardly on different platforms -- it is a platform issue
         not a Ruby or Puppet one, since the same variety exists when
         running commnands as different users in the shell."
       # Validation is handled by the SUIDManager class.
     end
 
-    newparam(:cwd) do
+    newparam(:cwd, :parent => Puppet::Parameter::Path) do
       desc "The directory from which to run the command.  If
         this directory does not exist, the command will fail."
-
-      validate do |dir|
-        unless dir =~ /^#{File::SEPARATOR}/
-          self.fail("CWD must be a fully qualified path")
-        end
-      end
-
-      munge do |dir|
-        dir = dir[0] if dir.is_a?(Array)
-
-        dir
-      end
     end
 
     newparam(:logoutput) do
       desc "Whether to log output.  Defaults to logging output at the
         loglevel for the `exec` resource. Use *on_failure* to only
         log the output when the command reports an error.  Values are
         **true**, *false*, *on_failure*, and any legal log level."
 
       newvalues(:true, :false, :on_failure)
     end
 
     newparam(:refresh) do
       desc "How to refresh this command.  By default, the exec is just
         called again when it receives an event from another resource,
         but this parameter allows you to define a different command
         for refreshing."
 
       validate do |command|
-        @resource.validatecmd(command)
+        provider.validatecmd(command)
       end
     end
 
     newparam(:environment) do
       desc "Any additional environment variables you want to set for a
         command.  Note that if you use this to set PATH, it will override
         the `path` attribute.  Multiple environment variables should be
         specified as an array."
 
       validate do |values|
         values = [values] unless values.is_a? Array
         values.each do |value|
           unless value =~ /\w+=/
             raise ArgumentError, "Invalid environment setting '#{value}'"
           end
         end
       end
     end
 
     newparam(:timeout) do
       desc "The maximum time the command should take.  If the command takes
         longer than the timeout, the command is considered to have failed
         and will be stopped.  Use any negative number to disable the timeout.
         The time is specified in seconds."
 
       munge do |value|
         value = value.shift if value.is_a?(Array)
         if value.is_a?(String)
           unless value =~ /^[-\d.]+$/
             raise ArgumentError, "The timeout must be a number."
           end
           Float(value)
         else
           value
         end
       end
 
       defaultto 300
     end
 
     newparam(:tries) do
       desc "The number of times execution of the command should be tried.
         Defaults to '1'. This many attempts will be made to execute
         the command until an acceptable return code is returned.
         Note that the timeout paramater applies to each try rather than
         to the complete set of tries."
 
       munge do |value|
         if value.is_a?(String)
           unless value =~ /^[\d]+$/
             raise ArgumentError, "Tries must be an integer"
           end
           value = Integer(value)
         end
         raise ArgumentError, "Tries must be an integer >= 1" if value < 1
         value
       end
 
       defaultto 1
     end
 
     newparam(:try_sleep) do
       desc "The time to sleep in seconds between 'tries'."
 
       munge do |value|
         if value.is_a?(String)
           unless value =~ /^[-\d.]+$/
             raise ArgumentError, "try_sleep must be a number"
           end
           value = Float(value)
         end
         raise ArgumentError, "try_sleep cannot be a negative number" if value < 0
         value
       end
 
       defaultto 0
     end
 
 
     newcheck(:refreshonly) do
       desc "The command should only be run as a
         refresh mechanism for when a dependent object is changed.  It only
         makes sense to use this option when this command depends on some
         other object; it is useful for triggering an action:
 
             # Pull down the main aliases file
             file { \"/etc/aliases\":
               source => \"puppet://server/module/aliases\"
             }
 
             # Rebuild the database, but only when the file changes
             exec { newaliases:
               path => [\"/usr/bin\", \"/usr/sbin\"],
               subscribe => File[\"/etc/aliases\"],
               refreshonly => true
             }
 
         Note that only `subscribe` and `notify` can trigger actions, not `require`,
         so it only makes sense to use `refreshonly` with `subscribe` or `notify`."
 
       newvalues(:true, :false)
 
       # We always fail this test, because we're only supposed to run
       # on refresh.
       def check(value)
         # We have to invert the values.
         if value == :true
           false
         else
           true
         end
       end
     end
 
-    newcheck(:creates) do
+    newcheck(:creates, :parent => Puppet::Parameter::Path) do
       desc "A file that this command creates.  If this
         parameter is provided, then the command will only be run
         if the specified file does not exist:
 
             exec { \"tar xf /my/tar/file.tar\":
               cwd => \"/var/tmp\",
               creates => \"/var/tmp/myfile\",
               path => [\"/usr/bin\", \"/usr/sbin\"]
             }
 
         "
 
-      # FIXME if they try to set this and fail, then we should probably
-      # fail the entire exec, right?
-      validate do |files|
-        files = [files] unless files.is_a? Array
-
-        files.each do |file|
-          self.fail("'creates' must be set to a fully qualified path") unless file
-
-          unless file =~ %r{^#{File::SEPARATOR}}
-            self.fail "'creates' files must be fully qualified."
-          end
-        end
-      end
+      accept_arrays
 
       # If the file exists, return false (i.e., don't run the command),
       # else return true
       def check(value)
         ! FileTest.exists?(value)
       end
     end
 
     newcheck(:unless) do
       desc "If this parameter is set, then this `exec` will run unless
         the command returns 0.  For example:
 
             exec { \"/bin/echo root >> /usr/lib/cron/cron.allow\":
               path => \"/usr/bin:/usr/sbin:/bin\",
               unless => \"grep root /usr/lib/cron/cron.allow 2>/dev/null\"
             }
 
         This would add `root` to the cron.allow file (on Solaris) unless
         `grep` determines it's already there.
 
         Note that this command follows the same rules as the main command,
         which is to say that it must be fully qualified if the path is not set.
         "
 
       validate do |cmds|
         cmds = [cmds] unless cmds.is_a? Array
 
-        cmds.each do |cmd|
-          @resource.validatecmd(cmd)
+        cmds.each do |command|
+          provider.validatecmd(command)
         end
       end
 
       # Return true if the command does not return 0.
       def check(value)
         begin
-          output, status = @resource.run(value, true)
+          output, status = provider.run(value, true)
         rescue Timeout::Error
           err "Check #{value.inspect} exceeded timeout"
           return false
         end
 
         status.exitstatus != 0
       end
     end
 
     newcheck(:onlyif) do
       desc "If this parameter is set, then this `exec` will only run if
         the command returns 0.  For example:
 
             exec { \"logrotate\":
               path => \"/usr/bin:/usr/sbin:/bin\",
               onlyif => \"test `du /var/log/messages | cut -f1` -gt 100000\"
             }
 
         This would run `logrotate` only if that test returned true.
 
         Note that this command follows the same rules as the main command,
         which is to say that it must be fully qualified if the path is not set.
 
         Also note that onlyif can take an array as its value, e.g.:
 
             onlyif => [\"test -f /tmp/file1\", \"test -f /tmp/file2\"]
 
         This will only run the exec if /all/ conditions in the array return true.
         "
 
       validate do |cmds|
         cmds = [cmds] unless cmds.is_a? Array
 
-        cmds.each do |cmd|
-          @resource.validatecmd(cmd)
+        cmds.each do |command|
+          provider.validatecmd(command)
         end
       end
 
       # Return true if the command returns 0.
       def check(value)
         begin
-          output, status = @resource.run(value, true)
+          output, status = provider.run(value, true)
         rescue Timeout::Error
           err "Check #{value.inspect} exceeded timeout"
           return false
         end
 
         status.exitstatus == 0
       end
     end
 
     # Exec names are not isomorphic with the objects.
     @isomorphic = false
 
     validate do
-      validatecmd(self[:command])
+      provider.validatecmd(self[:command])
     end
 
     # FIXME exec should autorequire any exec that 'creates' our cwd
     autorequire(:file) do
       reqs = []
 
       # Stick the cwd in there if we have it
       reqs << self[:cwd] if self[:cwd]
 
       self[:command].scan(/^(#{File::SEPARATOR}\S+)/) { |str|
         reqs << str
       }
 
       self[:command].scan(/^"([^"]+)"/) { |str|
         reqs << str
       }
 
       [:onlyif, :unless].each { |param|
         next unless tmp = self[param]
 
         tmp = [tmp] unless tmp.is_a? Array
 
         tmp.each do |line|
           # And search the command line for files, adding any we
           # find.  This will also catch the command itself if it's
           # fully qualified.  It might not be a bad idea to add
           # unqualified files, but, well, that's a bit more annoying
           # to do.
           reqs += line.scan(%r{(#{File::SEPARATOR}\S+)})
         end
       }
 
       # For some reason, the += isn't causing a flattening
       reqs.flatten!
 
       reqs
     end
 
     autorequire(:user) do
       # Autorequire users if they are specified by name
       if user = self[:user] and user !~ /^\d+$/
         user
       end
     end
 
     def self.instances
       []
     end
 
     # Verify that we pass all of the checks.  The argument determines whether
     # we skip the :refreshonly check, which is necessary because we now check
     # within refresh
-    def check(refreshing = false)
+    def check_all_attributes(refreshing = false)
       self.class.checks.each { |check|
         next if refreshing and check == :refreshonly
         if @parameters.include?(check)
           val = @parameters[check].value
           val = [val] unless val.is_a? Array
           val.each do |value|
             return false unless @parameters[check].check(value)
           end
         end
       }
 
       true
     end
 
-    # Verify that we have the executable
-    def checkexe(cmd)
-      exe = extractexe(cmd)
-
-      if self[:path]
-        if Puppet.features.posix? and !File.exists?(exe)
-          withenv :PATH => self[:path].join(File::PATH_SEPARATOR) do
-            exe = which(exe) || raise(ArgumentError,"Could not find command '#{exe}'")
-          end
-        elsif Puppet.features.microsoft_windows? and !File.exists?(exe)
-          self[:path].each do |path|
-            [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
-              file = File.join(path, exe+extension)
-              return if File.exists?(file)
-            end
-          end
-        end
-      end
-
-      raise ArgumentError, "Could not find executable '#{exe}'" unless FileTest.exists?(exe)
-      unless FileTest.executable?(exe)
-        raise ArgumentError,
-          "'#{exe}' is not executable"
-      end
-    end
-
     def output
       if self.property(:returns).nil?
         return nil
       else
         return self.property(:returns).output
       end
     end
 
     # Run the command, or optionally run a separately-specified command.
     def refresh
-      if self.check(true)
+      if self.check_all_attributes(true)
         if cmd = self[:refresh]
-          self.run(cmd)
+          provider.run(cmd)
         else
           self.property(:returns).sync
         end
       end
     end
-
-    # Run a command.
-    def run(command, check = false)
-      output = nil
-      status = nil
-
-      dir = nil
-
-      checkexe(command)
-
-      if dir = self[:cwd]
-        unless File.directory?(dir)
-          if check
-            dir = nil
-          else
-            self.fail "Working directory '#{dir}' does not exist"
-          end
-        end
-      end
-
-      dir ||= Dir.pwd
-
-      if check
-        debug "Executing check '#{command}'"
-      else
-        debug "Executing '#{command}'"
-      end
-      begin
-        # Do our chdir
-        Dir.chdir(dir) do
-          environment = {}
-
-          environment[:PATH] = self[:path].join(":") if self[:path]
-
-          if envlist = self[:environment]
-            envlist = [envlist] unless envlist.is_a? Array
-            envlist.each do |setting|
-              if setting =~ /^(\w+)=((.|\n)+)$/
-                name = $1
-                value = $2
-                if environment.include? name
-                  warning(
-                  "Overriding environment setting '#{name}' with '#{value}'"
-                  )
-                end
-                environment[name] = value
-              else
-                warning "Cannot understand environment setting #{setting.inspect}"
-              end
-            end
-          end
-
-          withenv environment do
-            Timeout::timeout(self[:timeout]) do
-              output, status = Puppet::Util::SUIDManager.run_and_capture(
-                [command], self[:user], self[:group]
-              )
-            end
-            # The shell returns 127 if the command is missing.
-            if status.exitstatus == 127
-              raise ArgumentError, output
-            end
-          end
-        end
-      rescue Errno::ENOENT => detail
-        self.fail detail.to_s
-      end
-
-      return output, status
-    end
-
-    def validatecmd(cmd)
-      exe = extractexe(cmd)
-      # if we're not fully qualified, require a path
-      self.fail "'#{cmd}' is not qualified and no path was specified. Please qualify the command or specify a path." if File.expand_path(exe) != exe and self[:path].nil?
-    end
-
-    def extractexe(cmd)
-      # easy case: command was quoted
-      if cmd =~ /^"([^"]+)"/
-        $1
-      else
-        cmd.split(/ /)[0]
-      end
-    end
   end
 end
diff --git a/spec/integration/transaction_spec.rb b/spec/integration/transaction_spec.rb
index b5080b5c6..ff15e597d 100755
--- a/spec/integration/transaction_spec.rb
+++ b/spec/integration/transaction_spec.rb
@@ -1,284 +1,278 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 require 'puppet_spec/files'
 require 'puppet/transaction'
 require 'puppet_spec/files'
 
 describe Puppet::Transaction do
   include PuppetSpec::Files
 
   before do
     Puppet::Util::Storage.stubs(:store)
   end
 
   def mk_catalog(*resources)
     catalog = Puppet::Resource::Catalog.new(Puppet::Node.new("mynode"))
     resources.each { |res| catalog.add_resource res }
     catalog
   end
 
   it "should not apply generated resources if the parent resource fails" do
     catalog = Puppet::Resource::Catalog.new
     resource = Puppet::Type.type(:file).new :path => "/foo/bar", :backup => false
     catalog.add_resource resource
 
     child_resource = Puppet::Type.type(:file).new :path => "/foo/bar/baz", :backup => false
 
     resource.expects(:eval_generate).returns([child_resource])
 
     transaction = Puppet::Transaction.new(catalog)
 
     resource.expects(:retrieve).raises "this is a failure"
     resource.stubs(:err)
 
     child_resource.expects(:retrieve).never
 
     transaction.evaluate
   end
 
   it "should not apply virtual resources" do
     catalog = Puppet::Resource::Catalog.new
     resource = Puppet::Type.type(:file).new :path => "/foo/bar", :backup => false
     resource.virtual = true
     catalog.add_resource resource
 
     transaction = Puppet::Transaction.new(catalog)
 
     resource.expects(:evaluate).never
 
     transaction.evaluate
   end
 
   it "should apply exported resources" do
     catalog = Puppet::Resource::Catalog.new
     path = tmpfile("exported_files")
     resource = Puppet::Type.type(:file).new :path => path, :backup => false, :ensure => :file
     resource.exported = true
     catalog.add_resource resource
 
     catalog.apply
     FileTest.should be_exist(path)
   end
 
   it "should not apply virtual exported resources" do
     catalog = Puppet::Resource::Catalog.new
     resource = Puppet::Type.type(:file).new :path => "/foo/bar", :backup => false
     resource.exported = true
     resource.virtual = true
     catalog.add_resource resource
 
     transaction = Puppet::Transaction.new(catalog)
 
     resource.expects(:evaluate).never
 
     transaction.evaluate
   end
 
   # Verify that one component requiring another causes the contained
   # resources in the requiring component to get refreshed.
   it "should propagate events from a contained resource through its container to its dependent container's contained resources" do
     transaction = nil
     file = Puppet::Type.type(:file).new :path => tmpfile("event_propagation"), :ensure => :present
     execfile = File.join(tmpdir("exec_event"), "exectestingness2")
     exec = Puppet::Type.type(:exec).new :command => "touch #{execfile}", :path => ENV['PATH']
     catalog = mk_catalog(file)
 
     fcomp = Puppet::Type.type(:component).new(:name => "Foo[file]")
     catalog.add_resource fcomp
     catalog.add_edge(fcomp, file)
 
     ecomp = Puppet::Type.type(:component).new(:name => "Foo[exec]")
     catalog.add_resource ecomp
     catalog.add_resource exec
     catalog.add_edge(ecomp, exec)
 
     ecomp[:subscribe] = Puppet::Resource.new(:foo, "file")
     exec[:refreshonly] = true
 
     exec.expects(:refresh)
     catalog.apply
   end
 
   # Make sure that multiple subscriptions get triggered.
   it "should propagate events to all dependent resources" do
     path = tmpfile("path")
     file1 = tmpfile("file1")
     file2 = tmpfile("file2")
 
-          file = Puppet::Type.type(:file).new(
-                
-      :path => path,
-        
+    file = Puppet::Type.type(:file).new(
+      :path   => path,
       :ensure => "file"
     )
 
-          exec1 = Puppet::Type.type(:exec).new(
-                
-      :path => ENV["PATH"],
+    exec1 = Puppet::Type.type(:exec).new(
+      :path    => ENV["PATH"],
       :command => "touch #{file1}",
       :refreshonly => true,
-        
-      :subscribe => Puppet::Resource.new(:file, path)
+      :subscribe   => Puppet::Resource.new(:file, path)
     )
 
-          exec2 = Puppet::Type.type(:exec).new(
-                
-      :path => ENV["PATH"],
-      :command => "touch #{file2}",
+    exec2 = Puppet::Type.type(:exec).new(
+      :path        => ENV["PATH"],
+      :command     => "touch #{file2}",
       :refreshonly => true,
-        
-      :subscribe => Puppet::Resource.new(:file, path)
+      :subscribe   => Puppet::Resource.new(:file, path)
     )
 
     catalog = mk_catalog(file, exec1, exec2)
     catalog.apply
     FileTest.should be_exist(file1)
     FileTest.should be_exist(file2)
   end
 
   it "should not let one failed refresh result in other refreshes failing" do
     path = tmpfile("path")
     newfile = tmpfile("file")
 
           file = Puppet::Type.type(:file).new(
                 
       :path => path,
         
       :ensure => "file"
     )
 
           exec1 = Puppet::Type.type(:exec).new(
                 
       :path => ENV["PATH"],
       :command => "touch /this/cannot/possibly/exist",
       :logoutput => true,
       :refreshonly => true,
       :subscribe => file,
         
       :title => "one"
     )
 
           exec2 = Puppet::Type.type(:exec).new(
                 
       :path => ENV["PATH"],
       :command => "touch #{newfile}",
       :logoutput => true,
       :refreshonly => true,
       :subscribe => [file, exec1],
         
       :title => "two"
     )
 
     exec1.stubs(:err)
 
     catalog = mk_catalog(file, exec1, exec2)
     catalog.apply
     FileTest.should be_exists(newfile)
   end
 
   it "should still trigger skipped resources" do
     catalog = mk_catalog
     catalog.add_resource(*Puppet::Type.type(:schedule).mkdefaultschedules)
 
     Puppet[:ignoreschedules] = false
 
           file = Puppet::Type.type(:file).new(
                 
       :name => tmpfile("file"),
         
       :ensure => "file",
       :backup => false
     )
 
     fname = tmpfile("exec")
 
           exec = Puppet::Type.type(:exec).new(
                 
       :name => "touch #{fname}",
       :path => "/usr/bin:/bin",
       :schedule => "monthly",
         
       :subscribe => Puppet::Resource.new("file", file.name)
     )
 
     catalog.add_resource(file, exec)
 
     # Run it once
     catalog.apply
     FileTest.should be_exists(fname)
 
     # Now remove it, so it can get created again
     File.unlink(fname)
 
     file[:content] = "some content"
 
     catalog.apply
     FileTest.should be_exists(fname)
 
     # Now remove it, so it can get created again
     File.unlink(fname)
 
     # And tag our exec
     exec.tag("testrun")
 
     # And our file, so it runs
     file.tag("norun")
 
     Puppet[:tags] = "norun"
 
     file[:content] = "totally different content"
 
     catalog.apply
     FileTest.should be_exists(fname)
   end
 
   it "should not attempt to evaluate resources with failed dependencies" do
 
           exec = Puppet::Type.type(:exec).new(
                 
       :command => "/bin/mkdir /this/path/cannot/possibly/exit",
         
       :title => "mkdir"
     )
 
 
           file1 = Puppet::Type.type(:file).new(
                 
       :title => "file1",
       :path => tmpfile("file1"),
         
       :require => exec,
       :ensure => :file
     )
 
 
           file2 = Puppet::Type.type(:file).new(
                 
       :title => "file2",
       :path => tmpfile("file2"),
         
       :require => file1,
       :ensure => :file
     )
 
     catalog = mk_catalog(exec, file1, file2)
     catalog.apply
 
     FileTest.should_not be_exists(file1[:path])
     FileTest.should_not be_exists(file2[:path])
   end
 
   # #801 -- resources only checked in noop should be rescheduled immediately.
   it "should immediately reschedule noop resources" do
     Puppet::Type.type(:schedule).mkdefaultschedules
     resource = Puppet::Type.type(:notify).new(:name => "mymessage", :noop => true)
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource resource
 
     trans = catalog.apply
 
     trans.resource_harness.should be_scheduled(trans.resource_status(resource), resource)
   end
 end
diff --git a/spec/lib/puppet_spec/verbose.rb b/spec/lib/puppet_spec/verbose.rb
new file mode 100644
index 000000000..d9834f2d7
--- /dev/null
+++ b/spec/lib/puppet_spec/verbose.rb
@@ -0,0 +1,9 @@
+# Support code for running stuff with warnings disabled.
+module Kernel
+  def with_verbose_disabled
+    verbose, $VERBOSE = $VERBOSE, nil
+    result = yield
+    $VERBOSE = verbose
+    return result
+  end
+end
diff --git a/spec/shared_behaviours/path_parameters.rb b/spec/shared_behaviours/path_parameters.rb
new file mode 100644
index 000000000..b5a907900
--- /dev/null
+++ b/spec/shared_behaviours/path_parameters.rb
@@ -0,0 +1,185 @@
+# In order to use this correctly you must define a method to get an instance
+# of the type being tested, so that this code can remain generic:
+#
+#    it_should_behave_like "all path parameters", :path do
+#      def instance(path)
+#        Puppet::Type.type(:example).new(
+#          :name => 'foo', :require => 'bar', :path_param => path
+#        )
+#      end
+#
+# That method will be invoked for each test to create the instance that we
+# subsequently test through the system; you should ensure that the minimum of
+# possible attributes are set to keep the tests clean.
+#
+# You must also pass the symbolic name of the parameter being tested to the
+# block, and optionally can pass a hash of additional options to the block.
+#
+# The known options are:
+#  :array :: boolean, does this support arrays of paths, default true.
+
+shared_examples_for "all pathname parameters with arrays" do |win32|
+  path_types = {
+    "unix absolute"  => "/foo/bar",
+    "unix relative"  => "foo/bar",
+    "win32 absolute" => %q{\foo\bar},
+    "win32 relative" => %q{foo\bar},
+    "drive absolute" => %q{c:\foo\bar},
+    "drive relative" => %q{c:foo\bar}
+  }
+
+  describe "when given an array of paths" do
+    (1..path_types.length).each do |n|
+      path_types.keys.combination(n) do |set|
+        data = path_types.collect { |k, v| set.member?(k) ? v : nil } .compact
+        reject = true
+        only_absolute = set.find { |k| k =~ /relative/ } .nil?
+        only_unix     = set.reject { |k| k =~ /unix/ } .length == 0
+
+        if only_absolute and (only_unix or win32) then
+          reject = false
+        end
+
+        it "should #{reject ? 'reject' : 'accept'} #{set.join(", ")}" do
+          if reject then
+            expect { instance(data) }.
+              should raise_error Puppet::Error, /fully qualified/
+          else
+            instance = instance(data)
+            instance[@param].should == data
+          end
+        end
+
+        it "should #{reject ? 'reject' : 'accept'} #{set.join(", ")} doubled" do
+          if reject then
+            expect { instance(data + data) }.
+              should raise_error Puppet::Error, /fully qualified/
+          else
+            instance = instance(data + data)
+            instance[@param].should == (data + data)
+          end
+        end
+      end
+    end
+  end
+end
+
+
+shared_examples_for "all path parameters" do |param, options|
+  # Extract and process options to the block.
+  options ||= {}
+  array = options[:array].nil? ? true : options.delete(:array)
+  if options.keys.length > 0 then
+    fail "unknown options for 'all path parameters': " +
+      options.keys.sort.join(', ')
+  end
+
+  def instance(path)
+    fail "we didn't implement the 'instance(path)' method in the it_should_behave_like block"
+  end
+
+  ########################################################################
+  # The actual testing code...
+  before :all do
+    @param = param
+  end
+
+  before :each do
+    @file_separator = File::SEPARATOR
+  end
+  after :each do
+    with_verbose_disabled do
+      verbose, $VERBOSE = $VERBOSE, nil
+      File::SEPARATOR = @file_separator
+      $VERBOSE = verbose
+    end
+  end
+
+  describe "on a Unix-like platform it" do
+    before :each do
+      with_verbose_disabled do
+        File::SEPARATOR = '/'
+      end
+      Puppet.features.stubs(:microsoft_windows?).returns(false)
+      Puppet.features.stubs(:posix?).returns(true)
+    end
+
+    if array then
+      it_should_behave_like "all pathname parameters with arrays", false
+    end
+
+    it "should accept a fully qualified path" do
+      path = File.join('', 'foo')
+      instance = instance(path)
+      instance[@param].should == path
+    end
+
+    it "should give a useful error when the path is not absolute" do
+      path = 'foo'
+      expect { instance(path) }.
+        should raise_error Puppet::Error, /fully qualified/
+    end
+
+    { "Unix" => '/', "Win32" => '\\' }.each do |style, slash|
+      %w{q Q a A z Z c C}.sort.each do |drive|
+        it "should reject drive letter '#{drive}' with #{style} path separators" do
+          path = "#{drive}:#{slash}Program Files"
+          expect { instance(path) }.
+            should raise_error Puppet::Error, /fully qualified/
+        end
+      end
+    end
+  end
+
+  describe "on a Windows-like platform it" do
+    before :each do
+      with_verbose_disabled do
+        File::SEPARATOR = '\\'
+      end
+      Puppet.features.stubs(:microsoft_windows?).returns(true)
+      Puppet.features.stubs(:posix?).returns(false)
+    end
+
+    if array then
+      it_should_behave_like "all pathname parameters with arrays", true
+    end
+
+    it "should accept a fully qualified path" do
+      path = File.join('', 'foo')
+      instance = instance(path)
+      instance[@param].should == path
+    end
+
+    it "should give a useful error when the path is not absolute" do
+      path = 'foo'
+      expect { instance(path) }.
+        should raise_error Puppet::Error, /fully qualified/
+    end
+
+    it "also accepts Unix style path separators" do
+      path = '/Program Files'
+      instance = instance(path)
+      instance[@param].should == path
+    end
+
+    { "Unix" => '/', "Win32" => '\\' }.each do |style, slash|
+      %w{q Q a A z Z c C}.sort.each do |drive|
+        it "should accept drive letter '#{drive}' with #{style} path separators " do
+          path = "#{drive}:#{slash}Program Files"
+          instance = instance(path)
+          instance[@param].should == path
+        end
+      end
+    end
+
+    { "UNC paths"            => %q{\\foo\bar},
+      "unparsed local paths" => %q{\\?\c:\foo},
+      "unparsed UNC paths"   => %q{\\?\foo\bar}
+    }.each do |name, path|
+      it "should accept #{name} as absolute" do
+        instance = instance(path)
+        instance[@param].should == path
+      end
+    end
+  end
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index d7f546b0b..13470428e 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,63 +1,69 @@
 unless defined?(SPEC_HELPER_IS_LOADED)
 SPEC_HELPER_IS_LOADED = 1
 
 dir = File.expand_path(File.dirname(__FILE__))
 
 $LOAD_PATH.unshift("#{dir}/")
 $LOAD_PATH.unshift("#{dir}/lib") # a spec-specific test lib dir
 $LOAD_PATH.unshift("#{dir}/../lib")
 
 # Don't want puppet getting the command line arguments for rake or autotest
 ARGV.clear
 
 require 'puppet'
 require 'mocha'
 gem 'rspec', '>=2.0.0'
 
 # So everyone else doesn't have to include this base constant.
 module PuppetSpec
   FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
 end
 
+require 'pathname'
+require 'lib/puppet_spec/verbose'
 require 'lib/puppet_spec/files'
 require 'lib/puppet_spec/fixtures'
 require 'monkey_patches/alias_should_to_must'
 require 'monkey_patches/publicize_methods'
 
+Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
+  require behaviour.relative_path_from(Pathname.new(dir))
+end
+
 RSpec.configure do |config|
   include PuppetSpec::Fixtures
 
   config.mock_with :mocha
 
   config.before :each do
     # these globals are set by Application
     $puppet_application_mode = nil
     $puppet_application_name = nil
     Signal.stubs(:trap)
 
     # Set the confdir and vardir to gibberish so that tests
     # have to be correctly mocked.
     Puppet[:confdir] = "/dev/null"
     Puppet[:vardir] = "/dev/null"
 
     # Avoid opening ports to the outside world
     Puppet.settings[:bindaddress] = "127.0.0.1"
 
     @logs = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(@logs))
   end
 
   config.after :each do
     Puppet.settings.clear
     Puppet::Node::Environment.clear
     Puppet::Util::Storage.clear
     Puppet::Util::ExecutionStub.reset
 
     PuppetSpec::Files.cleanup
 
     @logs.clear
     Puppet::Util::Log.close_all
   end
 end
 
 end
diff --git a/spec/unit/indirector/exec_spec.rb b/spec/unit/indirector/exec_spec.rb
index c6726d4b9..d4fb22443 100755
--- a/spec/unit/indirector/exec_spec.rb
+++ b/spec/unit/indirector/exec_spec.rb
@@ -1,56 +1,55 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/indirector/exec'
 
 describe Puppet::Indirector::Exec do
   before do
     @indirection = stub 'indirection', :name => :testing
     Puppet::Indirector::Indirection.expects(:instance).with(:testing).returns(@indirection)
     @exec_class = Class.new(Puppet::Indirector::Exec) do
       def self.to_s
         "Testing::Mytype"
       end
 
       attr_accessor :command
     end
 
     @searcher = @exec_class.new
     @searcher.command = ["/echo"]
 
     @request = stub 'request', :key => "foo"
   end
 
   it "should throw an exception if the command is not an array" do
     @searcher.command = "/usr/bin/echo"
     proc { @searcher.find(@request) }.should raise_error(Puppet::DevError)
   end
 
   it "should throw an exception if the command is not fully qualified" do
     @searcher.command = ["mycommand"]
     proc { @searcher.find(@request) }.should raise_error(ArgumentError)
   end
 
   it "should execute the command with the object name as the only argument" do
     @searcher.expects(:execute).with(%w{/echo foo})
     @searcher.find(@request)
   end
 
   it "should return the output of the script" do
     @searcher.expects(:execute).with(%w{/echo foo}).returns("whatever")
     @searcher.find(@request).should == "whatever"
   end
 
   it "should return nil when the command produces no output" do
     @searcher.expects(:execute).with(%w{/echo foo}).returns(nil)
     @searcher.find(@request).should be_nil
   end
 
-  it "should return nil and log an error if there's an execution failure" do
+  it "should raise an exception if there's an execution failure" do
     @searcher.expects(:execute).with(%w{/echo foo}).raises(Puppet::ExecutionFailure.new("message"))
 
-    Puppet.expects(:err)
-    @searcher.find(@request).should be_nil
+    lambda {@searcher.find(@request)}.should raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
   end
 end
diff --git a/spec/unit/parameter/path_spec.rb b/spec/unit/parameter/path_spec.rb
new file mode 100644
index 000000000..08a26de33
--- /dev/null
+++ b/spec/unit/parameter/path_spec.rb
@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), '../../spec_helper'))
+
+require 'puppet/parameter/path'
+
+[false, true].each do |arrays|
+  describe "Puppet::Parameter::Path with arrays #{arrays}" do
+    it_should_behave_like "all path parameters", :path, :array => arrays do
+      # The new type allows us a test that is guaranteed to go direct to our
+      # validation code, without passing through any "real type" overrides or
+      # whatever on the way.
+      Puppet::newtype(:test_puppet_parameter_path) do
+        newparam(:path, :parent => Puppet::Parameter::Path, :arrays => arrays) do
+          isnamevar
+          accept_arrays arrays
+        end
+      end
+
+      def instance(path)
+        Puppet::Type.type(:test_puppet_parameter_path).new(:path => path)
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/exec/posix_spec.rb b/spec/unit/provider/exec/posix_spec.rb
new file mode 100755
index 000000000..d02099250
--- /dev/null
+++ b/spec/unit/provider/exec/posix_spec.rb
@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:exec).provider(:posix)
+
+describe provider_class do
+  before :each do
+    @resource = Puppet::Resource.new(:exec, 'foo')
+    @provider = provider_class.new(@resource)
+  end
+
+  ["posix", "microsoft_windows"].each do |feature|
+    describe "when in #{feature} environment" do
+      before :each do
+        if feature == "microsoft_windows"
+          Puppet.features.stubs(:microsoft_windows?).returns(true)
+          Puppet.features.stubs(:posix?).returns(false)
+        else
+          Puppet.features.stubs(:posix?).returns(true)
+          Puppet.features.stubs(:microsoft_windows?).returns(false)
+        end
+      end
+
+      describe "#validatecmd" do
+        it "should fail if no path is specified and the command is not fully qualified" do
+          lambda { @provider.validatecmd("foo") }.should raise_error(
+            Puppet::Error,
+            "'foo' is not qualified and no path was specified. Please qualify the command or specify a path."
+          )
+        end
+
+        it "should pass if a path is given" do
+          @provider.resource[:path] = ['/bogus/bin']
+          @provider.validatecmd("../foo")
+        end
+
+        it "should pass if command is fully qualifed" do
+          @provider.resource[:path] = ['/bogus/bin']
+          @provider.validatecmd("/bin/blah/foo")
+        end
+      end
+
+      describe "#run" do
+        it "should fail if no path is specified and command does not exist" do
+          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "Could not find command 'foo'")
+        end
+
+        it "should fail if the command isn't in the path" do
+          @provider.resource[:path] = ['/bogus/bin']
+          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "Could not find command 'foo'")
+        end
+
+        it "should fail if the command isn't executable" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).with("foo").returns(true)
+
+          lambda { @provider.run("foo") }.should raise_error(ArgumentError, "'foo' is not executable")
+        end
+
+        it "should not be able to execute shell builtins" do
+          @provider.resource[:path] = ['/bin']
+          lambda { @provider.run("cd ..") }.should raise_error(ArgumentError, "Could not find command 'cd'")
+        end
+
+        it "should execute the command if the command given includes arguments or subcommands" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).returns(false)
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+
+          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo bar --sillyarg=true --blah']) && (arguments.is_a? Hash) }
+          @provider.run("foo bar --sillyarg=true --blah")
+        end
+
+        it "should fail if quoted command doesn't exist" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).returns(false)
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+
+          lambda { @provider.run('"foo bar --sillyarg=true --blah"') }.should raise_error(ArgumentError, "Could not find command 'foo bar --sillyarg=true --blah'")
+        end
+
+        it "should execute the command if it finds it in the path and is executable" do
+          @provider.resource[:path] = ['/bogus/bin']
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
+
+          @provider.run("foo")
+        end
+
+        if feature == "microsoft_windows"
+          [".exe", ".ps1", ".bat", ".com", ""].each do |extension|
+            it "should check file extension #{extension} when it can't find the executable" do
+              @provider.resource[:path] = ['/bogus/bin']
+              File.stubs(:exists?).returns(false)
+              File.stubs(:exists?).with("/bogus/bin/foo#{extension}").returns(true)
+              File.stubs(:executable?).with("foo").returns(true)
+              Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
+
+              @provider.run("foo")
+            end
+          end
+        end
+
+        it "should warn if you're overriding something in environment" do
+          @provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
+          File.stubs(:exists?).returns(false)
+          File.stubs(:exists?).with("foo").returns(true)
+          File.stubs(:executable?).with("foo").returns(true)
+
+          Puppet::Util.expects(:execute).with() { |command, arguments| (command == ['foo']) && (arguments.is_a? Hash) }
+          @provider.run("foo")
+          @logs.map {|l| "#{l.level}: #{l.message}" }.should == ["warning: Overriding environment setting 'WHATEVER' with '/foo'"]
+        end
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/exec/shell_spec.rb b/spec/unit/provider/exec/shell_spec.rb
new file mode 100644
index 000000000..4bae354c9
--- /dev/null
+++ b/spec/unit/provider/exec/shell_spec.rb
@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:exec).provider(:shell)
+
+describe provider_class do
+  before :each do
+    @resource = Puppet::Resource.new(:exec, 'foo')
+    @provider = provider_class.new(@resource)
+  end
+
+  describe "#run" do
+    it "should be able to run builtin shell commands" do
+      output, status = @provider.run("if [ 1 = 1 ]; then echo 'blah'; fi")
+      status.exitstatus.should == 0
+      output.should == "blah\n"
+    end
+
+    it "should be able to run commands with single quotes in them" do
+      output, status = @provider.run("echo 'foo  bar'")
+      status.exitstatus.should == 0
+      output.should == "foo  bar\n"
+    end
+
+    it "should be able to run commands with double quotes in them" do
+      output, status = @provider.run('echo "foo  bar"')
+      status.exitstatus.should == 0
+      output.should == "foo  bar\n"
+    end
+
+    it "should be able to run multiple commands separated by a semicolon" do
+      output, status = @provider.run("echo 'foo' ; echo 'bar'")
+      status.exitstatus.should == 0
+      output.should == "foo\nbar\n"
+    end
+
+    it "should be able to read values from the environment parameter" do
+      @resource[:environment] = "FOO=bar"
+      output, status = @provider.run("echo $FOO")
+      status.exitstatus.should == 0
+      output.should == "bar\n"
+    end
+  end
+
+  describe "#validatecmd" do
+    it "should always return true because builtins don't need path or to be fully qualified" do
+      @provider.validatecmd('whateverdoesntmatter').should == true
+    end
+  end
+end
diff --git a/spec/unit/type/cron_spec.rb b/spec/unit/type/cron_spec.rb
index 4d224c64b..5466b4d58 100755
--- a/spec/unit/type/cron_spec.rb
+++ b/spec/unit/type/cron_spec.rb
@@ -1,33 +1,481 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Puppet::Type.type(:cron) do
   before do
-    @cron = Puppet::Type.type(:cron).new( :name => "foo" )
-  end
+    @class = Puppet::Type.type(:cron)
+
+    # Init a fake provider
+    @provider_class = stub 'provider_class', :ancestors => [], :name => 'fake', :suitable? => true, :supports_parameter? => true
+    @class.stubs(:defaultprovider).returns @provider_class
+    @class.stubs(:provider).returns @provider_class
+
+    @provider = stub 'provider', :class => @provider_class, :clean => nil
+    @provider.stubs(:is_a?).returns false
+    @provider_class.stubs(:new).returns @provider
 
-  it "it should accept an :environment that looks like a path" do
-    lambda do
-      @cron[:environment] = 'PATH=/bin:/usr/bin:/usr/sbin'
-    end.should_not raise_error
+    @cron = @class.new( :name => "foo" )
   end
 
-  it "should not accept environment variables that do not contain '='" do
-    lambda do
-      @cron[:environment] = "INVALID"
-    end.should raise_error(Puppet::Error)
+  it "should have :name be its namevar" do
+    @class.key_attributes.should == [:name]
   end
 
-  it "should accept empty environment variables that do not contain '='" do
-    lambda do
-      @cron[:environment] = "MAILTO="
-    end.should_not raise_error(Puppet::Error)
+  describe "when validating attributes" do
+
+    [:name, :provider].each do |param|
+      it "should have a #{param} parameter" do
+        @class.attrtype(param).should == :param
+      end
+    end
+
+    [:command, :special, :minute, :hour, :weekday, :month, :monthday, :environment, :user, :target].each do |property|
+      it "should have a #{property} property" do
+        @class.attrtype(property).should == :property
+      end
+    end
+
+    [:command, :minute, :hour, :weekday, :month, :monthday].each do |cronparam|
+      it "should have #{cronparam} of type CronParam" do
+        @class.attrclass(cronparam).ancestors.should include CronParam
+      end
+    end
+
   end
 
-  it "should accept 'absent'" do
-    lambda do
-      @cron[:environment] = 'absent'
-    end.should_not raise_error(Puppet::Error)
+
+  describe "when validating attribute" do
+
+    describe "ensure" do
+      it "should support present as a value for ensure" do
+        proc { @class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
+      end
+
+      it "should support absent as a value for ensure" do
+        proc { @class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
+      end
+    end
+
+    describe "minute" do
+
+      it "should support absent" do
+        proc { @class.new(:name => 'foo', :minute => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :minute => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :minute => 'absent')[:minute].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :minute => '*')[:minute].should == :absent
+      end
+
+      it "should support valid single values" do
+        proc { @class.new(:name => 'foo', :minute => '0') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => '1') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => '59') }.should_not raise_error
+      end
+
+      it "should not support non numeric characters" do
+        proc { @class.new(:name => 'foo', :minute => 'z59') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '5z9') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '59z') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support single values out of range" do
+
+        proc { @class.new(:name => 'foo', :minute => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '60') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '61') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '120') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :minute => ['0','1','59'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => ['40','30','20'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => ['10','30','20'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :minute => ['0','1','60'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => ['0','120','59'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :minute => ['0','61','62'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :minute => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :minute => '10-16/2' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :minute => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :minute => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :minute => '*/120' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+    describe "hour" do
+
+     it "should support absent" do
+        proc { @class.new(:name => 'foo', :hour => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :hour => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :hour => 'absent')[:hour].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :hour => '*')[:hour].should == :absent
+      end
+
+      it "should support valid single values" do
+        proc { @class.new(:name => 'foo', :hour => '0') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '11') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '12') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '13') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '23') }.should_not raise_error
+      end
+
+      it "should not support non numeric characters" do
+        proc { @class.new(:name => 'foo', :hour => 'z15') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '1z5') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '15z') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support single values out of range" do
+        proc { @class.new(:name => 'foo', :hour => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '24') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '120') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :hour => ['0','1','23'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => ['5','16','14'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => ['16','13','9'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :hour => ['0','1','24'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :hour => ['0','25','26'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :hour => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :hour => '10-18/4' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :hour => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :hour => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :hour => '*/26' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+   describe "weekday" do
+
+      it "should support absent" do
+        proc { @class.new(:name => 'foo', :weekday => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :weekday => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :weekday => 'absent')[:weekday].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :weekday => '*')[:weekday].should == :absent
+      end
+
+      it "should support valid numeric weekdays" do
+        proc { @class.new(:name => 'foo', :weekday => '0') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => '1') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => '6') }.should_not raise_error
+        # According to http://www.manpagez.com/man/5/crontab 7 is also valid (Sunday)
+        proc { @class.new(:name => 'foo', :weekday => '7') }.should_not raise_error
+      end
+
+      it "should support valid weekdays as words (3 character version)" do
+        proc { @class.new(:name => 'foo', :weekday => 'Monday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Tuesday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Wednesday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Thursday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Friday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Saturday') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Sunday') }.should_not raise_error
+      end
+
+      it "should support valid weekdays as words (3 character version)" do
+        proc { @class.new(:name => 'foo', :weekday => 'Mon') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Tue') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Wed') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Thu') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Fri') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Sat') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => 'Sun') }.should_not raise_error
+      end
+
+      it "should not support numeric values out of range" do
+        proc { @class.new(:name => 'foo', :weekday => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :weekday => '8') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support invalid weekday names" do
+        proc { @class.new(:name => 'foo', :weekday => 'Sar') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :weekday => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :weekday => '0-4/2' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :weekday => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :weekday => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :weekday => '*/9' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+    describe "month" do
+
+      it "should support absent" do
+        proc { @class.new(:name => 'foo', :month => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :month => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :month => 'absent')[:month].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :month => '*')[:month].should == :absent
+      end
+
+      it "should support valid numeric values" do
+        proc { @class.new(:name => 'foo', :month => '1') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => '12') }.should_not raise_error
+      end
+
+      it "should support valid months as words" do
+        proc { @class.new(:name => 'foo', :month => 'January') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'February') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'March') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'April') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'May') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'June') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'July') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'August') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'September') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'October') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'November') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'December') }.should_not raise_error
+      end
+
+      it "should support valid months as words (3 character short version)" do
+        proc { @class.new(:name => 'foo', :month => 'Jan') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Feb') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Mar') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Apr') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'May') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Jun') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Jul') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Aug') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Sep') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Oct') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Nov') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => 'Dec') }.should_not raise_error
+      end
+
+      it "should not support numeric values out of range" do
+        proc { @class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '0') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '13') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support words that are not valid months" do
+        proc { @class.new(:name => 'foo', :month => 'Jal') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support single values out of range" do
+
+        proc { @class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '60') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '61') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '120') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :month => ['1','9','12'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :month => ['0','1','12'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => ['1','13','10'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :month => ['-1','0','13'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :month => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :month => '1-12/3' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :month => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :month => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :month => '*/13' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+    describe "monthday" do
+
+      it "should support absent" do
+        proc { @class.new(:name => 'foo', :monthday => 'absent') }.should_not raise_error
+      end
+
+      it "should support *" do
+        proc { @class.new(:name => 'foo', :monthday => '*') }.should_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        @class.new(:name => 'foo', :monthday => 'absent')[:monthday].should == :absent
+      end
+
+      it "should translate * to :absent" do
+        @class.new(:name => 'foo', :monthday => '*')[:monthday].should == :absent
+      end
+
+      it "should support valid single values" do
+        proc { @class.new(:name => 'foo', :monthday => '1') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => '30') }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => '31') }.should_not raise_error
+      end
+
+      it "should not support non numeric characters" do
+        proc { @class.new(:name => 'foo', :monthday => 'z23') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '2z3') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '23z') }.should raise_error(Puppet::Error)
+      end
+
+      it "should not support single values out of range" do
+        proc { @class.new(:name => 'foo', :monthday => '-1') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '0') }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '32') }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid multiple values" do
+        proc { @class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.should_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        proc { @class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.should raise_error(Puppet::Error)
+        # two invalid
+        proc { @class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.should raise_error(Puppet::Error)
+        # all invalid
+        proc { @class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.should raise_error(Puppet::Error)
+      end
+
+      it "should support valid step syntax" do
+        proc { @class.new(:name => 'foo', :monthday => '*/2' ) }.should_not raise_error
+        proc { @class.new(:name => 'foo', :monthday => '10-16/2' ) }.should_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        proc { @class.new(:name => 'foo', :monthday => '*/A' ) }.should raise_error(Puppet::Error)
+        proc { @class.new(:name => 'foo', :monthday => '*/2A' ) }.should raise_error(Puppet::Error)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # proc { @class.new(:name => 'foo', :monthday => '*/32' ) }.should raise_error(Puppet::Error)
+      end
+
+    end
+
+    describe "environment" do
+
+      it "it should accept an :environment that looks like a path" do
+        lambda do
+          @cron[:environment] = 'PATH=/bin:/usr/bin:/usr/sbin'
+        end.should_not raise_error
+      end
+
+      it "should not accept environment variables that do not contain '='" do
+        lambda do
+          @cron[:environment] = "INVALID"
+        end.should raise_error(Puppet::Error)
+      end
+
+      it "should accept empty environment variables that do not contain '='" do
+        lambda do
+          @cron[:environment] = "MAILTO="
+        end.should_not raise_error(Puppet::Error)
+      end
+
+      it "should accept 'absent'" do
+        lambda do
+          @cron[:environment] = 'absent'
+        end.should_not raise_error(Puppet::Error)
+      end
+
+    end
+
   end
 end
diff --git a/spec/unit/type/exec_spec.rb b/spec/unit/type/exec_spec.rb
index e980ec542..a1ffb1636 100755
--- a/spec/unit/type/exec_spec.rb
+++ b/spec/unit/type/exec_spec.rb
@@ -1,162 +1,648 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Puppet::Type.type(:exec) do
-
-  def create_resource(command, output, exitstatus, returns = 0)
-    @user_name = 'some_user_name'
+  def exec_tester(command, exitstatus = 0, rest = {})
+    @user_name  = 'some_user_name'
     @group_name = 'some_group_name'
     Puppet.features.stubs(:root?).returns(true)
-    @execer = Puppet::Type.type(:exec).new(:name => command, :path => @example_path, :user => @user_name, :group => @group_name, :returns => returns)
 
-    status = stub "process"
-    status.stubs(:exitstatus).returns(exitstatus)
+    output = rest.delete(:output) || ''
+    tries  = rest[:tries] || 1
+
+    args = {
+      :name      => command,
+      :path      => @example_path,
+      :user      => @user_name,
+      :group     => @group_name,
+      :logoutput => false,
+      :loglevel  => :err,
+      :returns   => 0
+    }.merge(rest)
+
+    exec = Puppet::Type.type(:exec).new(args)
+
+    status = stub "process", :exitstatus => exitstatus
+    Puppet::Util::SUIDManager.expects(:run_and_capture).times(tries).
+      with([command], @user_name, @group_name).returns([output, status])
 
-    Puppet::Util::SUIDManager.expects(:run_and_capture).with([command], @user_name, @group_name).returns([output, status])
+    return exec
   end
 
-  def create_logging_resource(command, output, exitstatus, logoutput, loglevel, returns = 0)
-    create_resource(command, output, exitstatus, returns)
-    @execer[:logoutput] = logoutput
-    @execer[:loglevel] = loglevel
+  before do
+    @command = Puppet.features.posix? ? '/bin/true whatever' : '"C:/Program Files/something.exe" whatever'
   end
 
-  def expect_output(output, loglevel)
-    output.split(/\n/).each do |line|
-      @execer.property(:returns).expects(loglevel).with(line)
+  describe "when not stubbing the provider" do
+    before do
+      @executable = Puppet.features.posix? ? '/bin/true' : 'C:/Program Files/something.exe'
+      File.stubs(:exists?).returns false
+      File.stubs(:exists?).with(@executable).returns true
+      File.stubs(:exists?).with('/bin/false').returns true
+      @example_path = Puppet.features.posix? ? %w{/usr/bin /bin} : [ "C:/Program Files/something/bin", "C:/Ruby/bin" ]
+      File.stubs(:exists?).with(File.join(@example_path[0],"true")).returns true
+      File.stubs(:exists?).with(File.join(@example_path[0],"false")).returns true
+    end
+
+    it "should return :executed_command as its event" do
+      resource = Puppet::Type.type(:exec).new :command => @command
+      resource.parameter(:returns).event.name.should == :executed_command
+    end
+
+    describe "when execing" do
+      it "should use the 'run_and_capture' method to exec" do
+        exec_tester("true").refresh.should == :executed_command
+      end
+
+      it "should report a failure" do
+        proc { exec_tester('false', 1).refresh }.
+          should raise_error(Puppet::Error, /^false returned 1 instead of/)
+      end
+
+      it "should not report a failure if the exit status is specified in a returns array" do
+        proc { exec_tester("false", 1, :returns => [0, 1]).refresh }.should_not raise_error
+      end
+
+      it "should report a failure if the exit status is not specified in a returns array" do
+        proc { exec_tester('false', 1, :returns => [0, 100]).refresh }.
+          should raise_error(Puppet::Error, /^false returned 1 instead of/)
+      end
+
+      it "should log the output on success" do
+        output = "output1\noutput2\n"
+        exec_tester('false', 0, :output => output, :logoutput => true).refresh
+        output.split("\n").each do |line|
+          log = @logs.shift
+          log.level.should == :err
+          log.message.should == line
+        end
+      end
+
+      it "should log the output on failure" do
+        output = "output1\noutput2\n"
+        proc { exec_tester('false', 1, :output => output, :logoutput => true).refresh }.
+          should raise_error(Puppet::Error)
+
+        output.split("\n").each do |line|
+          log = @logs.shift
+          log.level.should == :err
+          log.message.should == line
+        end
+      end
+    end
+
+    describe "when logoutput=>on_failure is set" do
+      it "should log the output on failure" do
+        output = "output1\noutput2\n"
+        proc { exec_tester('false', 1, :output => output, :logoutput => :on_failure).refresh }.
+          should raise_error(Puppet::Error, /^false returned 1 instead of/)
+
+        output.split("\n").each do |line|
+          log = @logs.shift
+          log.level.should == :err
+          log.message.should == line
+        end
+      end
+
+      it "should log the output on failure when returns is specified as an array" do
+        output = "output1\noutput2\n"
+
+        proc {
+          exec_tester('false', 1, :output => output, :returns => [0, 100],
+               :logoutput => :on_failure).refresh
+        }.should raise_error(Puppet::Error, /^false returned 1 instead of/)
+
+        output.split("\n").each do |line|
+          log = @logs.shift
+          log.level.should == :err
+          log.message.should == line
+        end
+      end
+
+      it "shouldn't log the output on success" do
+        exec_tester('true', 0, :output => "a\nb\nc\n", :logoutput => :on_failure).refresh
+        @logs.should == []
+      end
+    end
+
+    it "shouldn't log the output on success when non-zero exit status is in a returns array" do
+      exec_tester("true", 100, :output => "a\n", :logoutput => :on_failure, :returns => [1, 100]).refresh
+      @logs.should == []
+    end
+
+    describe " when multiple tries are set," do
+      it "should repeat the command attempt 'tries' times on failure and produce an error" do
+        tries = 5
+        resource = exec_tester("false", 1, :tries => tries, :try_sleep => 0)
+        proc { resource.refresh }.should raise_error(Puppet::Error)
+      end
     end
   end
 
-  before do
-    @executable = Puppet.features.posix? ? '/bin/true' : 'C:/Program Files/something.exe'
-    @command = Puppet.features.posix? ? '/bin/true whatever' : '"C:/Program Files/something.exe" whatever'
-    File.stubs(:exists?).returns false
-    File.stubs(:exists?).with(@executable).returns true
-    @example_path = Puppet.features.posix? ? %w{/usr/bin /bin} : [ "C:/Program Files/something/bin", "C:/Ruby/bin" ]
-    File.stubs(:exists?).with(File.join(@example_path[0],"true")).returns true
-    File.stubs(:exists?).with(File.join(@example_path[0],"false")).returns true
+  it "should be able to autorequire files mentioned in the command" do
+    catalog = Puppet::Resource::Catalog.new
+    tmp = Puppet::Type.type(:file).new(:name => "/bin/foo")
+    catalog.add_resource tmp
+    execer = Puppet::Type.type(:exec).new(:name => "/bin/foo")
+    catalog.add_resource execer
+
+    catalog.relationship_graph.dependencies(execer).should == [tmp]
+  end
+
+  describe "when handling the path parameter" do
+    expect = %w{one two three four}
+    { "an array"                        => expect,
+      "a colon separated list"          => "one:two:three:four",
+      "a semi-colon separated list"     => "one;two;three;four",
+      "both array and colon lists"      => ["one", "two:three", "four"],
+      "both array and semi-colon lists" => ["one", "two;three", "four"],
+      "colon and semi-colon lists"      => ["one:two", "three;four"]
+    }.each do |test, input|
+      it "should accept #{test}" do
+        type = Puppet::Type.type(:exec).new(:name => @command, :path => input)
+        type[:path].should == expect
+      end
+    end
   end
 
-  it "should return :executed_command as its event" do
-    resource = Puppet::Type.type(:exec).new :command => @command
-    resource.parameter(:returns).event.name.should == :executed_command
+  describe "when setting user" do
+    it "should fail if we are not root" do
+      Puppet.features.stubs(:root?).returns(false)
+      expect { Puppet::Type.type(:exec).new(:name => @command, :user => 'input') }.
+        should raise_error Puppet::Error, /Parameter user failed/
+    end
+
+    ['one', 2, 'root', 4294967295, 4294967296].each do |value|
+      it "should accept '#{value}' as user if we are root" do
+        Puppet.features.stubs(:root?).returns(true)
+        type = Puppet::Type.type(:exec).new(:name => @command, :user => value)
+        type[:user].should == value
+      end
+    end
   end
 
-  describe "when execing" do
+  describe "when setting group" do
+    shared_examples_for "exec[:group]" do
+      ['one', 2, 'wheel', 4294967295, 4294967296].each do |value|
+        it "should accept '#{value}' without error or judgement" do
+          type = Puppet::Type.type(:exec).new(:name => @command, :group => value)
+          type[:group].should == value
+        end
+      end
+    end
+
+    describe "when running as root" do
+      before :each do Puppet.features.stubs(:root?).returns(true) end
+      it_behaves_like "exec[:group]"
+    end
+
+    describe "when not running as root" do
+      before :each do Puppet.features.stubs(:root?).returns(false) end
+      it_behaves_like "exec[:group]"
+    end
+  end
+
+  describe "when setting cwd" do
+    it_should_behave_like "all path parameters", :cwd, :array => false do
+      def instance(path)
+        Puppet::Type.type(:exec).new(:name => '/bin/true', :cwd => path)
+      end
+    end
+  end
+
+  shared_examples_for "all exec command parameters" do |param|
+    { "relative" => "example", "absolute" => "/bin/example" }.sort.each do |name, command|
+      describe "if command is #{name}" do
+        before :each do
+          @param = param
+        end
+
+        def test(command, valid)
+          if @param == :name then
+            instance = Puppet::Type.type(:exec).new()
+          else
+            instance = Puppet::Type.type(:exec).new(:name => "/bin/true")
+          end
+          if valid then
+            instance.provider.expects(:validatecmd).returns(true)
+          else
+            instance.provider.expects(:validatecmd).raises(Puppet::Error, "from a stub")
+          end
+          instance[@param] = command
+        end
+
+        it "should work if the provider calls the command valid" do
+          expect { test(command, true) }.should_not raise_error
+        end
+
+        it "should fail if the provider calls the command invalid" do
+          expect { test(command, false) }.
+            should raise_error Puppet::Error, /Parameter #{@param} failed: from a stub/
+        end
+      end
+    end
+  end
+
+  shared_examples_for "all exec command parameters that take arrays" do |param|
+    describe "when given an array of inputs" do
+      before :each do
+        @test = Puppet::Type.type(:exec).new(:name => "/bin/true")
+      end
+
+      it "should accept the array when all commands return valid" do
+        input = %w{one two three}
+        @test.provider.expects(:validatecmd).times(input.length).returns(true)
+        @test[param] = input
+        @test[param].should == input
+      end
 
-    it "should use the 'run_and_capture' method to exec" do
-      command = "true"
-      create_resource(command, "", 0)
+      it "should reject the array when any commands return invalid" do
+        input = %w{one two three}
+        @test.provider.expects(:validatecmd).with(input.first).returns(false)
+        input[1..-1].each do |cmd|
+          @test.provider.expects(:validatecmd).with(cmd).returns(true)
+        end
+        @test[param] = input
+        @test[param].should == input
+      end
 
-      @execer.refresh.should == :executed_command
+      it "should reject the array when all commands return invalid" do
+        input = %w{one two three}
+        @test.provider.expects(:validatecmd).times(input.length).returns(false)
+        @test[param] = input
+        @test[param].should == input
+      end
     end
+  end
 
-    it "should report a failure" do
-      command = "false"
-      create_resource(command, "", 1)
+  describe "when setting refresh" do
+    it_should_behave_like "all exec command parameters", :refresh
+  end
 
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+  describe "for simple parameters" do
+    before :each do
+      @exec = Puppet::Type.type(:exec).new(:name => '/bin/true')
     end
 
-    it "should not report a failure if the exit status is specified in a returns array" do
-      command = "false"
-      create_resource(command, "", 1, [0,1])
-      proc { @execer.refresh }.should_not raise_error(Puppet::Error)
+    describe "when setting environment" do
+      { "single values"   => "foo=bar",
+        "multiple values" => ["foo=bar", "baz=quux"],
+      }.each do |name, data|
+        it "should accept #{name}" do
+          @exec[:environment] = data
+          @exec[:environment].should == data
+        end
+      end
+
+      { "single values" => "foo",
+        "only values"   => ["foo", "bar"],
+        "any values"    => ["foo=bar", "baz"]
+      }.each do |name, data|
+        it "should reject #{name} without assignment" do
+          expect { @exec[:environment] = data }.
+            should raise_error Puppet::Error, /Invalid environment setting/
+        end
+      end
+    end
+
+    describe "when setting timeout" do
+      [-3.5, -1, 0, 0.1, 1, 10, 4294967295].each do |valid|
+        it "should accept '#{valid}' as valid" do
+          @exec[:timeout] = valid
+          @exec[:timeout].should == valid
+        end
+
+        it "should accept '#{valid}' in an array as valid" do
+          @exec[:timeout] = [valid]
+          @exec[:timeout].should == valid
+        end
+      end
+
+      ['1/2', '1_000_000', '+12', '', 'foo'].each do |invalid|
+        it "should reject '#{invalid}' as invalid" do
+          expect { @exec[:timeout] = invalid }.
+            should raise_error Puppet::Error, /The timeout must be a number/
+        end
+
+        it "should reject '#{invalid}' in an array as invalid" do
+          expect { @exec[:timeout] = [invalid] }.
+            should raise_error Puppet::Error, /The timeout must be a number/
+        end
+      end
+
+      it "should fail if timeout is exceeded" do
+        File.stubs(:exists?).with('/bin/sleep').returns(true)
+        File.stubs(:exists?).with('sleep').returns(false)
+        sleep_exec = Puppet::Type.type(:exec).new(:name => 'sleep 1', :path => ['/bin'], :timeout => '0.2')
+        lambda { sleep_exec.refresh }.should raise_error Puppet::Error, "Command exceeded timeout"
+      end
     end
 
-    it "should report a failure if the exit status is not specified in a returns array" do
-      command = "false"
-      create_resource(command, "", 1, [0,100])
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+    describe "when setting tries" do
+      [1, 10, 4294967295].each do |valid|
+        it "should accept '#{valid}' as valid" do
+          @exec[:tries] = valid
+          @exec[:tries].should == valid
+        end
+
+        if "REVISIT: too much test log spam" == "a good thing" then
+          it "should accept '#{valid}' in an array as valid" do
+            pending "inconsistent, but this is not supporting arrays, unlike timeout"
+            @exec[:tries] = [valid]
+            @exec[:tries].should == valid
+          end
+        end
+      end
+
+      [-3.5, -1, 0, 0.2, '1/2', '1_000_000', '+12', '', 'foo'].each do |invalid|
+        it "should reject '#{invalid}' as invalid" do
+          expect { @exec[:tries] = invalid }.
+            should raise_error Puppet::Error, /Tries must be an integer/
+        end
+
+        if "REVISIT: too much test log spam" == "a good thing" then
+          it "should reject '#{invalid}' in an array as invalid" do
+            pending "inconsistent, but this is not supporting arrays, unlike timeout"
+            expect { @exec[:tries] = [invalid] }.
+              should raise_error Puppet::Error, /Tries must be an integer/
+          end
+        end
+      end
     end
 
-    it "should log the output on success" do
-      #Puppet::Util::Log.newdestination :console
-      command = "false"
-      output = "output1\noutput2\n"
-      create_logging_resource(command, output, 0, true, :err)
-      expect_output(output, :err)
-      @execer.refresh
+    describe "when setting try_sleep" do
+      [0, 0.2, 1, 10, 4294967295].each do |valid|
+        it "should accept '#{valid}' as valid" do
+          @exec[:try_sleep] = valid
+          @exec[:try_sleep].should == valid
+        end
+
+        if "REVISIT: too much test log spam" == "a good thing" then
+          it "should accept '#{valid}' in an array as valid" do
+            pending "inconsistent, but this is not supporting arrays, unlike timeout"
+            @exec[:try_sleep] = [valid]
+            @exec[:try_sleep].should == valid
+          end
+        end
+      end
+
+      { -3.5        => "cannot be a negative number",
+        -1          => "cannot be a negative number",
+        '1/2'       => 'must be a number',
+        '1_000_000' => 'must be a number',
+        '+12'       => 'must be a number',
+        ''          => 'must be a number',
+        'foo'       => 'must be a number',
+      }.each do |invalid, error|
+        it "should reject '#{invalid}' as invalid" do
+          expect { @exec[:try_sleep] = invalid }.
+            should raise_error Puppet::Error, /try_sleep #{error}/
+        end
+
+        if "REVISIT: too much test log spam" == "a good thing" then
+          it "should reject '#{invalid}' in an array as invalid" do
+            pending "inconsistent, but this is not supporting arrays, unlike timeout"
+            expect { @exec[:try_sleep] = [invalid] }.
+              should raise_error Puppet::Error, /try_sleep #{error}/
+          end
+        end
+      end
     end
 
-    it "should log the output on failure" do
-      #Puppet::Util::Log.newdestination :console
-      command = "false"
-      output = "output1\noutput2\n"
-      create_logging_resource(command, output, 1, true, :err)
-      expect_output(output, :err)
+    describe "when setting refreshonly" do
+      [:true, :false].each do |value|
+        it "should accept '#{value}'" do
+          @exec[:refreshonly] = value
+          @exec[:refreshonly].should == value
+        end
+      end
 
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+      [1, 0, "1", "0", "yes", "y", "no", "n"].each do |value|
+        it "should reject '#{value}'" do
+          expect { @exec[:refreshonly] = value }.
+            should raise_error(Puppet::Error,
+              /Invalid value #{value.inspect}\. Valid values are true, false/
+            )
+        end
+      end
     end
 
+    describe "when setting creates" do
+      it_should_behave_like "all path parameters", :creates, :array => true do
+        def instance(path)
+          Puppet::Type.type(:exec).new(:name => '/bin/true', :creates => path)
+        end
+      end
+    end
   end
 
-  describe "when logoutput=>on_failure is set" do
+  describe "when setting unless" do
+    it_should_behave_like "all exec command parameters", :unless
+    it_should_behave_like "all exec command parameters that take arrays", :unless
+  end
 
-    it "should log the output on failure" do
-      #Puppet::Util::Log.newdestination :console
-      command = "false"
-      output = "output1\noutput2\n"
-      create_logging_resource(command, output, 1, :on_failure, :err)
-      expect_output(output, :err)
+  describe "when setting onlyif" do
+    it_should_behave_like "all exec command parameters", :onlyif
+    it_should_behave_like "all exec command parameters that take arrays", :onlyif
+  end
 
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+  describe "#check" do
+    before :each do
+      @test = Puppet::Type.type(:exec).new(:name => "/bin/true")
     end
 
-    it "should log the output on failure when returns is specified as an array" do
-      #Puppet::Util::Log.newdestination :console
-      command = "false"
-      output = "output1\noutput2\n"
-      create_logging_resource(command, output, 1, :on_failure, :err, [0, 100])
-      expect_output(output, :err)
+    describe ":refreshonly" do
+      { :true => false, :false => true }.each do |input, result|
+        it "should return '#{result}' when given '#{input}'" do
+          @test[:refreshonly] = input
+          @test.check_all_attributes.should == result
+        end
+      end
+    end
+
+    describe ":creates" do
+      before :all do
+        @exist   = "/"
+        @unexist = "/this/path/should/never/exist"
+        while FileTest.exist?(@unexist) do @unexist += "/foo" end
+      end
+
+      context "with a single item" do
+        it "should run when the item does not exist" do
+          @test[:creates] = @unexist
+          @test.check_all_attributes.should == true
+        end
 
-      proc { @execer.refresh }.should raise_error(Puppet::Error)
+        it "should not run when the item exists" do
+          @test[:creates] = @exist
+          @test.check_all_attributes.should == false
+        end
+      end
+
+      context "with an array with one item" do
+        it "should run when the item does not exist" do
+          @test[:creates] = [@unexist]
+          @test.check_all_attributes.should == true
+        end
+
+        it "should not run when the item exists" do
+          @test[:creates] = [@exist]
+          @test.check_all_attributes.should == false
+        end
+      end
+
+      context "with an array with multiple items" do
+        it "should run when all items do not exist" do
+          @test[:creates] = [@unexist] * 3
+          @test.check_all_attributes.should == true
+        end
+
+        it "should not run when one item exists" do
+          @test[:creates] = [@unexist, @exist, @unexist]
+          @test.check_all_attributes.should == false
+        end
+
+        it "should not run when all items exist" do
+          @test[:creates] = [@exist] * 3
+        end
+      end
     end
 
-    it "shouldn't log the output on success" do
-      #Puppet::Util::Log.newdestination :console
-      command = "true"
-      output = "output1\noutput2\n"
-      create_logging_resource(command, output, 0, :on_failure, :err)
-      @execer.property(:returns).expects(:err).never
-      @execer.refresh
+    { :onlyif => { :pass => false, :fail => true  },
+      :unless => { :pass => true,  :fail => false },
+    }.each do |param, sense|
+      describe ":#{param}" do
+        before :each do
+          @pass = "/magic/pass"
+          @fail = "/magic/fail"
+
+          @pass_status = stub('status', :exitstatus => sense[:pass] ? 0 : 1)
+          @fail_status = stub('status', :exitstatus => sense[:fail] ? 0 : 1)
+
+          @test.provider.stubs(:checkexe).returns(true)
+          [true, false].each do |check|
+            @test.provider.stubs(:run).with(@pass, check).
+              returns(['test output', @pass_status])
+            @test.provider.stubs(:run).with(@fail, check).
+              returns(['test output', @fail_status])
+          end
+        end
+
+        context "with a single item" do
+          it "should run if the command exits non-zero" do
+            @test[param] = @fail
+            @test.check_all_attributes.should == true
+          end
+
+          it "should not run if the command exits zero" do
+            @test[param] = @pass
+            @test.check_all_attributes.should == false
+          end
+        end
+
+        context "with an array with a single item" do
+          it "should run if the command exits non-zero" do
+            @test[param] = [@fail]
+            @test.check_all_attributes.should == true
+          end
+
+          it "should not run if the command exits zero" do
+            @test[param] = [@pass]
+            @test.check_all_attributes.should == false
+          end
+        end
+
+        context "with an array with multiple items" do
+          it "should run if all the commands exits non-zero" do
+            @test[param] = [@fail] * 3
+            @test.check_all_attributes.should == true
+          end
+
+          it "should not run if one command exits zero" do
+            @test[param] = [@pass, @fail, @pass]
+            @test.check_all_attributes.should == false
+          end
+
+          it "should not run if all command exits zero" do
+            @test[param] = [@pass] * 3
+            @test.check_all_attributes.should == false
+          end
+        end
+      end
     end
   end
 
-  it "shouldn't log the output on success when non-zero exit status is in a returns array" do
-    #Puppet::Util::Log.newdestination :console
-    command = "true"
-    output = "output1\noutput2\n"
-    create_logging_resource(command, output, 100, :on_failure, :err, [1,100])
-    @execer.property(:returns).expects(:err).never
-    @execer.refresh
+  describe "#retrieve" do
+    before :each do
+      @exec_resource = Puppet::Type.type(:exec).new(:name => "/bogus/cmd")
+    end
+
+    it "should return :notrun when check_all_attributes returns true" do
+      @exec_resource.stubs(:check_all_attributes).returns true
+      @exec_resource.retrieve[:returns].should == :notrun
+    end
+
+    it "should return default exit code 0 when check_all_attributes returns false" do
+      @exec_resource.stubs(:check_all_attributes).returns false
+      @exec_resource.retrieve[:returns].should == ['0']
+    end
+
+    it "should return the specified exit code when check_all_attributes returns false" do
+      @exec_resource.stubs(:check_all_attributes).returns false
+      @exec_resource[:returns] = 42
+      @exec_resource.retrieve[:returns].should == ["42"]
+    end
   end
 
-  describe " when multiple tries are set," do
+  describe "#output" do
+    before :each do
+      @exec_resource = Puppet::Type.type(:exec).new(:name => "/bogus/cmd")
+    end
+
+    it "should return the provider's run output" do
+      provider = stub 'provider'
+      status = stubs "process_status"
+      status.stubs(:exitstatus).returns("0")
+      provider.expects(:run).returns(["silly output", status])
+      @exec_resource.stubs(:provider).returns(provider)
 
-    it "should repeat the command attempt 'tries' times on failure and produce an error" do
-      Puppet.features.stubs(:root?).returns(true)
-      command = "false"
-      user = "user"
-      group = "group"
-      tries = 5
-      retry_exec = Puppet::Type.type(:exec).new(:name => command, :path => %w{/usr/bin /bin}, :user => user, :group => group, :returns => 0, :tries => tries, :try_sleep => 0)
-      status = stub "process"
-      status.stubs(:exitstatus).returns(1)
-      Puppet::Util::SUIDManager.expects(:run_and_capture).with([command], user, group).times(tries).returns(["", status])
-      proc { retry_exec.refresh }.should raise_error(Puppet::Error)
+      @exec_resource.refresh
+      @exec_resource.output.should == 'silly output'
     end
   end
 
-  it "should be able to autorequire files mentioned in the command" do
-    catalog = Puppet::Resource::Catalog.new
-    catalog.add_resource Puppet::Type.type(:file).new(:name => @executable)
-    @execer = Puppet::Type.type(:exec).new(:name => @command)
-    catalog.add_resource @execer
+  describe "#refresh" do
+    before :each do
+      @exec_resource = Puppet::Type.type(:exec).new(:name => "/bogus/cmd")
+    end
+
+    it "should call provider run with the refresh parameter if it is set" do
+      provider = stub 'provider'
+      @exec_resource.stubs(:provider).returns(provider)
+      @exec_resource.stubs(:[]).with(:refresh).returns('/myother/bogus/cmd')
+      provider.expects(:run).with('/myother/bogus/cmd')
 
-    rels = @execer.autorequire
-    rels[0].should be_instance_of(Puppet::Relationship)
-    rels[0].target.should equal(@execer)
+      @exec_resource.refresh
+    end
+
+    it "should call provider run with the specified command if the refresh parameter is not set" do
+      provider = stub 'provider'
+      status = stubs "process_status"
+      status.stubs(:exitstatus).returns("0")
+      provider.expects(:run).with('/bogus/cmd').returns(["silly output", status])
+      @exec_resource.stubs(:provider).returns(provider)
+
+      @exec_resource.refresh
+    end
+
+    it "should not run the provider if check_all_attributes is false" do
+      @exec_resource.stubs(:check_all_attributes).returns false
+      provider = stub 'provider'
+      provider.expects(:run).never
+      @exec_resource.stubs(:provider).returns(provider)
+
+      @exec_resource.refresh
+    end
   end
 end
diff --git a/test/ral/type/exec.rb b/test/ral/type/exec.rb
index 829b1a068..0831d466d 100755
--- a/test/ral/type/exec.rb
+++ b/test/ral/type/exec.rb
@@ -1,804 +1,717 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../lib/puppettest')
 
 require 'puppettest'
 
 class TestExec < Test::Unit::TestCase
   include PuppetTest
   def test_numvsstring
     [0, "0"].each { |val|
       command = nil
       output = nil
       assert_nothing_raised {
 
         command = Puppet::Type.type(:exec).new(
 
           :command => "/bin/echo",
 
           :returns => val
         )
       }
       assert_events([:executed_command], command)
     }
   end
 
   def test_path_or_qualified
     command = nil
     output = nil
     assert_raise(Puppet::Error) {
       command = Puppet::Type.type(:exec).new(
         :command => "echo"
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "echo",
-
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin"
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin"
       )
     }
     assert_nothing_raised {
       command = Puppet::Type.type(:exec).new(
         :command => "/bin/echo"
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "/bin/echo",
-
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin"
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin"
       )
     }
   end
 
   def test_nonzero_returns
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "mkdir /this/directory/does/not/exist",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :returns => 1
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "touch /etc",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :returns => 1
       )
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "thiscommanddoesnotexist",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :returns => 127
       )
     }
   end
 
   def test_cwdsettings
     command = nil
     dir = "/tmp"
     wd = Dir.chdir(dir) {
       Dir.getwd
     }
     assert_nothing_raised {
 
       command = Puppet::Type.type(:exec).new(
-
         :command => "pwd",
-        :cwd => dir,
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :cwd     => dir,
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :returns => 0
       )
     }
     assert_events([:executed_command], command)
     assert_equal(wd,command.output.chomp)
   end
 
   def test_refreshonly_functional
     file = nil
     cmd = nil
     tmpfile = tempfile
     @@tmpfiles.push tmpfile
     trans = nil
 
-      file = Puppet::Type.type(:file).new(
-
-        :path => tmpfile,
-
-        :content => "yay"
+    file = Puppet::Type.type(:file).new(
+      :path    => tmpfile,
+      :content => "yay"
     )
     # Get the file in sync
     assert_apply(file)
 
     # Now make an exec
     maker = tempfile
     assert_nothing_raised {
-
       cmd = Puppet::Type.type(:exec).new(
-
-        :command => "touch #{maker}",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-        :subscribe => file,
-
+        :command     => "touch #{maker}",
+        :path        => "/usr/bin:/bin:/usr/sbin:/sbin",
+        :subscribe   => file,
         :refreshonly => true
       )
     }
 
     assert(cmd, "did not make exec")
 
     assert_nothing_raised do
-      assert(! cmd.check, "Check passed when refreshonly is set")
+      assert(! cmd.check_all_attributes, "Check passed when refreshonly is set")
     end
 
     assert_events([], file, cmd)
     assert(! FileTest.exists?(maker), "made file without refreshing")
 
     # Now change our content, so we throw a refresh
     file[:content] = "yayness"
     assert_events([:content_changed, :restarted], file, cmd)
     assert(FileTest.exists?(maker), "file was not made in refresh")
   end
 
   def test_refreshonly
     cmd = true
     assert_nothing_raised {
-
       cmd = Puppet::Type.type(:exec).new(
-
-        :command => "pwd",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :command     => "pwd",
+        :path        => "/usr/bin:/bin:/usr/sbin:/sbin",
         :refreshonly => true
       )
     }
 
     # Checks should always fail when refreshonly is enabled
-    assert(!cmd.check, "Check passed with refreshonly true")
+    assert(!cmd.check_all_attributes, "Check passed with refreshonly true")
 
     # Now make sure it passes if we pass in "true"
-    assert(cmd.check(true), "Check failed with refreshonly true while refreshing")
+    assert(cmd.check_all_attributes(true), "Check failed with refreshonly true while refreshing")
 
     # Now set it to false
     cmd[:refreshonly] = false
-    assert(cmd.check, "Check failed with refreshonly false")
+    assert(cmd.check_all_attributes, "Check failed with refreshonly false")
   end
 
   def test_creates
     file = tempfile
     exec = nil
     assert(! FileTest.exists?(file), "File already exists")
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
-
         :command => "touch #{file}",
-        :path => "/usr/bin:/bin:/usr/sbin:/sbin",
-
+        :path    => "/usr/bin:/bin:/usr/sbin:/sbin",
         :creates => file
       )
     }
 
     comp = mk_catalog("createstest", exec)
     assert_events([:executed_command], comp, "creates")
     assert_events([], comp, "creates")
   end
 
   # Verify that we can download the file that we're going to execute.
   def test_retrievethenmkexe
     exe = tempfile
     oexe = tempfile
     sh = %x{which sh}
     File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
 
-
-      file = Puppet::Type.type(:file).new(
-
-        :path => oexe,
-        :source => exe,
-
-        :mode => 0755
+    file = Puppet::Type.type(:file).new(
+      :path => oexe,
+      :source => exe,
+      :mode => 0755
     )
 
-
-      exec = Puppet::Type.type(:exec).new(
-
-        :command => oexe,
-
-        :require => Puppet::Resource.new(:file, oexe)
+    exec = Puppet::Type.type(:exec).new(
+      :command => oexe,
+      :require => Puppet::Resource.new(:file, oexe)
     )
 
     comp = mk_catalog("Testing", file, exec)
 
     assert_events([:file_created, :executed_command], comp)
   end
 
   # Verify that we auto-require any managed scripts.
   def test_autorequire_files
     exe = tempfile
     oexe = tempfile
     sh = %x{which sh}
     File.open(exe, "w") { |f| f.puts "#!#{sh}\necho yup" }
 
 
-      file = Puppet::Type.type(:file).new(
-
-        :path => oexe,
-        :source => exe,
-
-        :mode => 755
+    file = Puppet::Type.type(:file).new(
+      :path => oexe,
+      :source => exe,
+      :mode => 755
     )
 
     basedir = File.dirname(oexe)
 
-      baseobj = Puppet::Type.type(:file).new(
-
-        :path => basedir,
-        :source => exe,
-
-        :mode => 755
+    baseobj = Puppet::Type.type(:file).new(
+      :path   => basedir,
+      :source => exe,
+      :mode   => 755
     )
 
 
-      ofile = Puppet::Type.type(:file).new(
-
-        :path => exe,
-
-        :mode => 755
+    ofile = Puppet::Type.type(:file).new(
+      :path => exe,
+      :mode => 755
     )
 
 
-      exec = Puppet::Type.type(:exec).new(
-
-        :command => oexe,
-        :path => ENV["PATH"],
-
-        :cwd => basedir
+    exec = Puppet::Type.type(:exec).new(
+      :command => oexe,
+      :path => ENV["PATH"],
+      :cwd => basedir
     )
 
-
-      cat = Puppet::Type.type(:exec).new(
-
-        :command => "cat #{exe} #{oexe}",
-
-        :path => ENV["PATH"]
+    cat = Puppet::Type.type(:exec).new(
+      :command => "cat #{exe} #{oexe}",
+      :path => ENV["PATH"]
     )
 
     catalog = mk_catalog(file, baseobj, ofile, exec, cat)
 
     rels = nil
     assert_nothing_raised do
       rels = exec.autorequire
     end
 
     # Verify we get the script itself
     assert(rels.detect { |r| r.source == file }, "Exec did not autorequire its command")
 
     # Verify we catch the cwd
     assert(rels.detect { |r| r.source == baseobj }, "Exec did not autorequire its cwd")
 
     # Verify we don't require ourselves
     assert(! rels.detect { |r| r.source == ofile }, "Exec incorrectly required mentioned file")
 
     # We not longer autorequire inline files
     assert_nothing_raised do
       rels = cat.autorequire
     end
     assert(! rels.detect { |r| r.source == ofile }, "Exec required second inline file")
     assert(! rels.detect { |r| r.source == file }, "Exec required inline file")
   end
 
   def test_ifonly
     afile = tempfile
     bfile = tempfile
 
     exec = nil
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
-
         :command => "touch #{bfile}",
-        :onlyif => "test -f #{afile}",
-
-        :path => ENV['PATH']
+        :onlyif  => "test -f #{afile}",
+        :path    => ENV['PATH']
       )
     }
 
     assert_events([], exec)
     system("touch #{afile}")
     assert_events([:executed_command], exec)
     assert_events([:executed_command], exec)
     system("rm #{afile}")
     assert_events([], exec)
   end
 
   def test_unless
     afile = tempfile
     bfile = tempfile
 
     exec = nil
     assert_nothing_raised {
-
       exec = Puppet::Type.type(:exec).new(
-
         :command => "touch #{bfile}",
         :unless => "test -f #{afile}",
-
         :path => ENV['PATH']
       )
     }
     comp = mk_catalog(exec)
 
     assert_events([:executed_command], comp)
     assert_events([:executed_command], comp)
     system("touch #{afile}")
     assert_events([], comp)
     assert_events([], comp)
     system("rm #{afile}")
     assert_events([:executed_command], comp)
     assert_events([:executed_command], comp)
   end
 
   if Puppet.features.root?
     # Verify that we can execute commands as a special user
     def mknverify(file, user, group = nil, id = true)
       File.umask(0022)
 
       args = {
         :command => "touch #{file}",
         :path => "/usr/bin:/bin:/usr/sbin:/sbin",
       }
 
       if user
         #Puppet.warning "Using user #{user.name}"
         if id
           # convert to a string, because that's what the object expects
           args[:user] = user.uid.to_s
         else
           args[:user] = user.name
         end
       end
 
       if group
         #Puppet.warning "Using group #{group.name}"
         if id
           args[:group] = group.gid.to_s
         else
           args[:group] = group.name
         end
       end
       exec = nil
       assert_nothing_raised {
         exec = Puppet::Type.type(:exec).new(args)
       }
 
       comp = mk_catalog("usertest", exec)
       assert_events([:executed_command], comp, "usertest")
 
       assert(FileTest.exists?(file), "File does not exist")
       assert_equal(user.uid, File.stat(file).uid, "File UIDs do not match") if user
 
       # We can't actually test group ownership, unfortunately, because
       # behaviour changes wildlly based on platform.
       Puppet::Type.allclear
     end
 
     def test_userngroup
       file = tempfile
       [
         [nonrootuser], # just user, by name
         [nonrootuser, nil, true], # user, by uid
         [nil, nonrootgroup], # just group
         [nil, nonrootgroup, true], # just group, by id
         [nonrootuser, nonrootgroup], # user and group, by name
         [nonrootuser, nonrootgroup, true], # user and group, by id
       ].each { |ary|
         mknverify(file, *ary) {
         }
       }
     end
   end
 
   def test_logoutput
     exec = nil
     assert_nothing_raised {
-
       exec = Puppet::Type.type(:exec).new(
-
-        :title => "logoutputesting",
-        :path => "/usr/bin:/bin",
-        :command => "echo logoutput is false",
-
+        :title     => "logoutputesting",
+        :path      => "/usr/bin:/bin",
+        :command   => "echo logoutput is false",
         :logoutput => false
       )
     }
 
     assert_apply(exec)
 
     assert_nothing_raised {
       exec[:command] = "echo logoutput is true"
       exec[:logoutput] = true
     }
 
     assert_apply(exec)
 
     assert_nothing_raised {
       exec[:command] = "echo logoutput is on_failure"
       exec[:logoutput] = "on_failure"
     }
 
     assert_apply(exec)
   end
 
   def test_execthenfile
     exec = nil
     file = nil
     basedir = tempfile
     path = File.join(basedir, "subfile")
     assert_nothing_raised {
 
       exec = Puppet::Type.type(:exec).new(
-
-        :title => "mkdir",
-        :path => "/usr/bin:/bin",
+        :title   => "mkdir",
+        :path    => "/usr/bin:/bin",
         :creates => basedir,
-
         :command => "mkdir #{basedir}; touch #{path}"
-
       )
     }
 
     assert_nothing_raised {
 
       file = Puppet::Type.type(:file).new(
-
-        :path => basedir,
+        :path    => basedir,
         :recurse => true,
-        :mode => "755",
-
+        :mode    => "755",
         :require => Puppet::Resource.new("exec", "mkdir")
       )
     }
 
     comp = mk_catalog(file, exec)
     comp.finalize
     assert_events([:executed_command, :mode_changed], comp)
 
     assert(FileTest.exists?(path), "Exec ran first")
     assert(File.stat(path).mode & 007777 == 0755)
   end
 
   # Make sure all checks need to be fully qualified.
   def test_falsevals
     exec = nil
     assert_nothing_raised do
       exec = Puppet::Type.type(:exec).new(
         :command => "/bin/touch yayness"
       )
     end
 
     Puppet::Type.type(:exec).checks.each do |check|
       klass = Puppet::Type.type(:exec).paramclass(check)
       next if klass.value_collection.values.include? :false
       assert_raise(Puppet::Error, "Check '#{check}' did not fail on false") do
         exec[check] = false
       end
     end
   end
 
   def test_createcwdandexe
     exec1 = exec2 = nil
     dir = tempfile
     file = tempfile
 
     assert_nothing_raised {
-
       exec1 = Puppet::Type.type(:exec).new(
-
-        :title => "one",
-        :path => ENV["PATH"],
-
+        :title   => "one",
+        :path    => ENV["PATH"],
         :command => "mkdir #{dir}"
       )
     }
 
     assert_nothing_raised("Could not create exec w/out existing cwd") {
 
       exec2 = Puppet::Type.type(:exec).new(
-
-        :title => "two",
-        :path => ENV["PATH"],
+        :title   => "two",
+        :path    => ENV["PATH"],
         :command => "touch #{file}",
-
-        :cwd => dir
+        :cwd     => dir
       )
     }
 
     # Throw a check in there with our cwd and make sure it works
     assert_nothing_raised("Could not check with a missing cwd") do
       exec2[:unless] = "test -f /this/file/does/not/exist"
       exec2.retrieve
     end
 
     assert_raise(Puppet::Error) do
       exec2.property(:returns).sync
     end
 
     assert_nothing_raised do
       exec2[:require] = exec1
     end
 
     assert_apply(exec1, exec2)
 
     assert(FileTest.exists?(file))
   end
 
   def test_checkarrays
     exec = nil
     file = tempfile
 
     test = "test -f #{file}"
 
     assert_nothing_raised {
-
       exec = Puppet::Type.type(:exec).new(
-
-        :path => ENV["PATH"],
-
+        :path    => ENV["PATH"],
         :command => "touch #{file}"
       )
     }
 
     assert_nothing_raised {
       exec[:unless] = test
     }
 
     assert_nothing_raised {
-      assert(exec.check, "Check did not pass")
+      assert(exec.check_all_attributes, "Check did not pass")
     }
 
     assert_nothing_raised {
       exec[:unless] = [test, test]
     }
 
 
     assert_nothing_raised {
       exec.finish
     }
 
     assert_nothing_raised {
-      assert(exec.check, "Check did not pass")
+      assert(exec.check_all_attributes, "Check did not pass")
     }
 
     assert_apply(exec)
 
     assert_nothing_raised {
-      assert(! exec.check, "Check passed")
+      assert(! exec.check_all_attributes, "Check passed")
     }
   end
 
   def test_missing_checks_cause_failures
     # Solaris's sh exits with 1 here instead of 127
     return if Facter.value(:operatingsystem) == "Solaris"
 
       exec = Puppet::Type.type(:exec).new(
-
         :command => "echo true",
-        :path => ENV["PATH"],
-
-        :onlyif => "/bin/nosuchthingexists"
-          )
+        :path    => ENV["PATH"],
+        :onlyif  => "/bin/nosuchthingexists"
+      )
 
     assert_raise(ArgumentError, "Missing command did not raise error") {
-      exec.run("/bin/nosuchthingexists")
+      exec.provider.run("/bin/nosuchthingexists")
     }
   end
 
   def test_environmentparam
 
     exec = Puppet::Type.newexec(
-
-      :command => "echo $environmenttest",
-      :path => ENV["PATH"],
-
+      :command     => "echo $environmenttest",
+      :path        => ENV["PATH"],
       :environment => "environmenttest=yayness"
     )
 
     assert(exec, "Could not make exec")
 
     output = status = nil
     assert_nothing_raised {
-      output, status = exec.run("echo $environmenttest")
+      output, status = exec.provider.run("echo $environmenttest")
     }
 
     assert_equal("yayness\n", output)
 
     # Now check whether we can do multiline settings
     assert_nothing_raised do
       exec[:environment] = "environmenttest=a list of things
 and stuff"
   end
 
   output = status = nil
   assert_nothing_raised {
-    output, status = exec.run('echo "$environmenttest"')
+    output, status = exec.provider.run('echo "$environmenttest"')
     }
     assert_equal("a list of things\nand stuff\n", output)
 
     # Now test arrays
     assert_nothing_raised do
       exec[:environment] = ["funtest=A", "yaytest=B"]
     end
 
     output = status = nil
     assert_nothing_raised {
-      output, status = exec.run('echo "$funtest" "$yaytest"')
+      output, status = exec.provider.run('echo "$funtest" "$yaytest"')
     }
     assert_equal("A B\n", output)
   end
 
-  def test_timeout
-    exec = Puppet::Type.type(:exec).new(:command => "sleep 1", :path => ENV["PATH"], :timeout => "0.2")
-    time = Time.now
-
-    assert_raise(Timeout::Error) {
-      exec.run("sleep 1")
-    }
-    Puppet.info "#{Time.now.to_f - time.to_f} seconds, vs a timeout of #{exec[:timeout]}"
-
-
-    assert_apply(exec)
-  end
-
   # Testing #470
   def test_run_as_created_user
     exec = nil
     if Process.uid == 0
       user = "nosuchuser"
       assert_nothing_raised("Could not create exec with non-existent user") do
-
         exec = Puppet::Type.type(:exec).new(
-
           :command => "/bin/echo yay",
-
-          :user => user
+          :user    => user
         )
       end
     end
 
     # Now try the group
     group = "nosuchgroup"
     assert_nothing_raised("Could not create exec with non-existent user") do
 
       exec = Puppet::Type.type(:exec).new(
-
         :command => "/bin/echo yay",
-
-        :group => group
+        :group   => group
       )
     end
   end
 
   # make sure paths work both as arrays and strings
   def test_paths_as_arrays
     path = %w{/usr/bin /usr/sbin /sbin}
     exec = nil
     assert_nothing_raised("Could not use an array for the path") do
       exec = Puppet::Type.type(:exec).new(:command => "echo yay", :path => path)
     end
     assert_equal(path, exec[:path], "array-based path did not match")
     assert_nothing_raised("Could not use a string for the path") do
       exec = Puppet::Type.type(:exec).new(:command => "echo yay", :path => path.join(":"))
     end
     assert_equal(path, exec[:path], "string-based path did not match")
     assert_nothing_raised("Could not use a colon-separated strings in an array for the path") do
       exec = Puppet::Type.type(:exec).new(:command => "echo yay", :path => ["/usr/bin", "/usr/sbin:/sbin"])
     end
     assert_equal(path, exec[:path], "colon-separated array path did not match")
   end
 
   def test_checks_apply_to_refresh
     file = tempfile
     maker = tempfile
 
-      exec = Puppet::Type.type(:exec).new(
-
-        :title => "maker",
-        :command => "touch #{maker}",
-
-        :path => ENV["PATH"]
+    exec = Puppet::Type.type(:exec).new(
+      :title   => "maker",
+      :command => "touch #{maker}",
+      :path    => ENV["PATH"]
     )
 
     # Make sure it runs normally
     assert_apply(exec)
     assert(FileTest.exists?(maker), "exec did not run")
     File.unlink(maker)
 
     # Now make sure it refreshes
     assert_nothing_raised("Failed to refresh exec") do
       exec.refresh
     end
     assert(FileTest.exists?(maker), "exec did not run refresh")
     File.unlink(maker)
 
     # Now add the checks
     exec[:creates] = file
 
     # Make sure it runs when the file doesn't exist
     assert_nothing_raised("Failed to refresh exec") do
       exec.refresh
     end
     assert(FileTest.exists?(maker), "exec did not refresh when checks passed")
     File.unlink(maker)
 
     # Now create the file and make sure it doesn't refresh
     File.open(file, "w") { |f| f.puts "" }
     assert_nothing_raised("Failed to refresh exec") do
       exec.refresh
     end
     assert(! FileTest.exists?(maker), "exec refreshed with failing checks")
   end
 
   def test_explicit_refresh
     refresher = tempfile
     maker = tempfile
 
-      exec = Puppet::Type.type(:exec).new(
-
-        :title => "maker",
-        :command => "touch #{maker}",
-
-        :path => ENV["PATH"]
+    exec = Puppet::Type.type(:exec).new(
+      :title => "maker",
+      :command => "touch #{maker}",
+      :path => ENV["PATH"]
     )
 
     # Call refresh normally
     assert_nothing_raised do
       exec.refresh
     end
 
     # Make sure it created the normal file
     assert(FileTest.exists?(maker), "normal refresh did not work")
     File.unlink(maker)
 
     # Now reset refresh, and make sure it wins
     assert_nothing_raised("Could not set refresh parameter") do
       exec[:refresh] = "touch #{refresher}"
     end
     assert_nothing_raised do
       exec.refresh
     end
 
     # Make sure it created the normal file
     assert(FileTest.exists?(refresher), "refresh param was ignored")
     assert(! FileTest.exists?(maker), "refresh param also ran command")
   end
 
   if Puppet.features.root?
     def test_autorequire_user
       user = Puppet::Type.type(:user).new(:name => "yay")
       exec = Puppet::Type.type(:exec).new(:command => "/bin/echo fun", :user => "yay")
 
       rels = nil
       assert_nothing_raised("Could not evaluate autorequire") do
         rels = exec.autorequire
       end
       assert(rels.find { |r| r.source == user and r.target == exec }, "Exec did not autorequire user")
     end
   end
 end
-