diff --git a/manifests/run.pp b/manifests/run.pp
index db87c09..1f01f65 100755
--- a/manifests/run.pp
+++ b/manifests/run.pp
@@ -1,532 +1,534 @@
 # == Define: docker:run
 #
 # A define which manages a running docker container.
 #
 # == Parameters
 #
 # [*restart*]
 # Sets a restart policy on the docker run.
 # Note: If set, puppet will NOT setup an init script to manage, instead
 # it will do a raw docker run command using a CID file to track the container
 # ID.
 #
 # If you want a normal named container with an init script and a restart policy
 # you must use the extra_parameters feature and pass it in like this:
 #
 #    extra_parameters => ['--restart=always']
 #
 # However, if your system is using sytemd this restart policy will be
 # ineffective because the ExecStop commands will run which will cause
 # docker to stop restarting it.  In this case you should use the
 # systemd_restart option to specify the policy you want.
 #
 # This will allow the docker container to be restarted if it dies, without
 # puppet help.
 #
 # [*service_prefix*]
 #   (optional) The name to prefix the startup script with and the Puppet
 #   service resource title with.  Default: 'docker-'
 #
 # [*restart_service*]
 #   (optional) Whether or not to restart the service if the the generated init
 #   script changes.  Default: true
 #
 # [*restart_service_on_docker_refresh*]
 #   Whether or not to restart the service if the docker service is restarted.
 #   Only has effect if the docker_service parameter is set.
 #   Default: true
 #
 # [*manage_service*]
 #  (optional) Whether or not to create a puppet Service resource for the init
 #  script.  Disabling this may be useful if integrating with existing modules.
 #  Default: true
 #
 # [*docker_service*]
 #  (optional) If (and how) the Docker service itself is managed by Puppet
 #  true          -> Service['docker']
 #  false         -> no Service dependency
 #  anything else -> Service[docker_service]
 #  Default: false
 #
 # [*health_check_cmd*]
 # (optional) Specifies the command to execute to check that the container is healthy using the docker health check functionality.
 # Default: undef
 #
 # [*health_check_interval*]
 # (optional) Specifies the interval that the health check command will execute in seconds.
 # Default: undef
 #
 # [*restart_on_unhealthy*]
 # (optional) Checks the health status of Docker container and if it is unhealthy the service will be restarted.
 # The health_check_cmd parameter must be set to true to use this functionality.
 # Default: undef
 #
 # [*net*]
 #
 # The docker network to attach to a container.
 # Can be a String or Array (if using multiple networks)
 # Default: bridge
 #
 # [*extra_parameters*]
 # An array of additional command line arguments to pass to the `docker run`
 # command. Useful for adding additional new or experimental options that the
 # module does not yet support.
 #
 # [*systemd_restart*]
 # (optional) If the container is to be managed by a systemd unit file set the
 # Restart option on the unit file.  Can be any valid value for this systemd
 # configuration.  Most commonly used are on-failure or always.
 # Default: on-failure
 #
 # [*custom_unless*]
 # (optional) Specify an additional unless for the Docker run command when using restart.
 # Default: undef
 #
 # [*after_create*]
 # (optional) Specifies the command to execute after container is created but before it is started.
 # Default: undef
 #
 define docker::run(
   Optional[Pattern[/^[\S]*$/]] $image,
   Optional[Pattern[/^present$|^absent$/]] $ensure       = 'present',
   Optional[String] $command                             = undef,
   Optional[Pattern[/^[\d]*(b|k|m|g)$/]] $memory_limit   = '0b',
   Variant[String,Array,Undef] $cpuset                   = [],
   Variant[String,Array,Undef] $ports                    = [],
   Variant[String,Array,Undef] $labels                   = [],
   Variant[String,Array,Undef] $expose                   = [],
   Variant[String,Array,Undef] $volumes                  = [],
   Variant[String,Array,Undef] $links                    = [],
   Optional[Boolean] $use_name                           = false,
   Optional[Boolean] $running                            = true,
   Variant[String,Array,Undef] $volumes_from             = [],
   Variant[String,Array] $net                            = 'bridge',
   Variant[String,Boolean] $username                     = false,
   Variant[String,Boolean] $hostname                     = false,
   Variant[String,Array,Undef] $env                      = [],
   Variant[String,Array,Undef] $env_file                 = [],
   Variant[String,Array,Undef] $dns                      = [],
   Variant[String,Array,Undef] $dns_search               = [],
   Variant[String,Array,Undef] $lxc_conf                 = [],
   Optional[String] $service_prefix                      = 'docker-',
   Optional[Boolean] $restart_service                    = true,
   Optional[Boolean] $restart_service_on_docker_refresh  = true,
   Optional[Boolean] $manage_service                     = true,
   Variant[String,Boolean] $docker_service               = false,
   Optional[Boolean] $disable_network                    = false,
   Optional[Boolean] $privileged                         = false,
   Optional[Boolean] $detach                             = undef,
   Variant[String,Array[String],Undef] $extra_parameters = undef,
   Optional[String] $systemd_restart                     = 'on-failure',
   Variant[String,Hash,Undef] $extra_systemd_parameters  = {},
   Optional[Boolean] $pull_on_start                      = false,
   Variant[String,Array,Undef] $after                    = [],
   Variant[String,Array,Undef] $after_service            = [],
   Variant[String,Array,Undef] $depends                  = [],
   Variant[String,Array,Undef] $depend_services          = [],
   Optional[Boolean] $tty                                = false,
   Variant[String,Array,Undef] $socket_connect           = [],
   Variant[String,Array,Undef] $hostentries              = [],
   Optional[String] $restart                             = undef,
   Variant[String,Boolean] $before_start                 = false,
   Variant[String,Boolean] $before_stop                  = false,
   Optional[String]  $after_create                       = undef,
   Optional[Boolean] $remove_container_on_start          = true,
   Optional[Boolean] $remove_container_on_stop           = true,
   Optional[Boolean] $remove_volume_on_start             = false,
   Optional[Boolean] $remove_volume_on_stop              = false,
   Optional[Integer] $stop_wait_time                     = 0,
   Optional[String]  $syslog_identifier                  = undef,
   Optional[Boolean] $read_only                          = false,
   Optional[String]  $health_check_cmd                   = undef,
   Optional[Boolean] $restart_on_unhealthy               = false,
   Optional[Integer] $health_check_interval              = undef,
   Variant[String,Array,Undef] $custom_unless            = [],
 ) {
   include docker::params
   if ($socket_connect != []) {
     $sockopts = join(any2array($socket_connect), ',')
     $docker_command = "${docker::params::docker_command} -H ${sockopts}"
   }else {
     $docker_command = $docker::params::docker_command
   }
   $service_name = $docker::service_name
   $docker_group = $docker::docker_group
 
   if $restart {
     assert_type(Pattern[/^(no|always|unless-stopped|on-failure)|^on-failure:[\d]+$/], $restart)
   }
 
   if ($remove_volume_on_start and !$remove_container_on_start) {
     fail(translate("In order to remove the volume on start for ${title} you need to also remove the container"))
   }
 
   if ($remove_volume_on_stop and !$remove_container_on_stop) {
     fail(translate("In order to remove the volume on stop for ${title} you need to also remove the container"))
   }
 
   if $use_name {
     notify { "docker use_name warning: ${title}":
       message  => 'The use_name parameter is no-longer required and will be removed in a future release',
       withpath => true,
     }
   }
 
   if $systemd_restart {
     assert_type(Pattern[/^(no|always|on-success|on-failure|on-abnormal|on-abort|on-watchdog)$/], $systemd_restart)
   }
 
   if $detach == undef {
     $valid_detach = $docker::params::detach_service_in_init
   } else {
     $valid_detach = $detach
   }
 
   $extra_parameters_array = any2array($extra_parameters)
   $after_array = any2array($after)
   $depends_array = any2array($depends)
   $depend_services_array = any2array($depend_services)
 
   $docker_run_flags = docker_run_flags({
     cpuset                => any2array($cpuset),
     disable_network       => $disable_network,
     dns                   => any2array($dns),
     dns_search            => any2array($dns_search),
     env                   => any2array($env),
     env_file              => any2array($env_file),
     expose                => any2array($expose),
     extra_params          => any2array($extra_parameters),
     hostentries           => any2array($hostentries),
     hostname              => $hostname,
     links                 => any2array($links),
     lxc_conf              => any2array($lxc_conf),
     memory_limit          => $memory_limit,
     net                   => $net,
     ports                 => any2array($ports),
     labels                => any2array($labels),
     privileged            => $privileged,
     socket_connect        => any2array($socket_connect),
     tty                   => $tty,
     username              => $username,
     volumes               => any2array($volumes),
     volumes_from          => any2array($volumes_from),
     read_only             => $read_only,
     health_check_cmd      => $health_check_cmd,
     restart_on_unhealthy  => $restart_on_unhealthy,
     health_check_interval => $health_check_interval,
     osfamily              => $::osfamily,
   })
 
   $sanitised_title = docker::sanitised_name($title)
   if empty($depends_array) {
     $sanitised_depends_array = []
   }
   else {
     $sanitised_depends_array = docker::sanitised_name($depends_array)
   }
 
   if empty($after_array) {
     $sanitised_after_array = []
   }
   else {
     $sanitised_after_array = docker::sanitised_name($after_array)
   }
 
   if $::osfamily == 'windows' {
     $exec_environment = "PATH=${::docker_program_files_path}/Docker/;${::docker_systemroot}/System32/"
     $exec_timeout = 3000
     $exec_path = ["${::docker_program_files_path}/Docker/"]
     $exec_provider = 'powershell'
     $cidfile = "${::docker_user_temp_path}/${service_prefix}${sanitised_title}.cid"
 # lint:ignore:140chars
     $restart_check = "${docker_command} inspect ${sanitised_title} -f '{{ if eq \\\"unhealthy\\\" .State.Health.Status }} {{ .Name }}{{ end }}' | findstr ${sanitised_title}"
+    $container_running_check = "\$state = ${docker_command} inspect ${sanitised_title} -f \"{{ .State.Running }}\"; if (\$state -ieq \"true\") { Exit 0 } else { Exit 1 }"
 # lint:endignore
   } else {
     $exec_environment = 'HOME=/root'
     $exec_path = ['/bin', '/usr/bin']
     $exec_timeout = 0
     $exec_provider = undef
     $cidfile = "/var/run/${service_prefix}${sanitised_title}.cid"
 # lint:ignore:140chars
     $restart_check = "${docker_command} inspect ${sanitised_title} -f '{{ if eq \"unhealthy\" .State.Health.Status }} {{ .Name }}{{ end }}' | grep ${sanitised_title}"
+    $container_running_check = "${docker_command} inspect ${sanitised_title} -f \"{{ .State.Running }}\" | grep true"
 # lint:endignore
   }
 
   if $restart_on_unhealthy {
     exec { "Restart unhealthy container ${title} with docker":
       command     => "${docker_command} restart ${sanitised_title}",
       onlyif      => $restart_check,
       environment => $exec_environment,
       path        => $exec_path,
       provider    => $exec_provider,
       timeout     => $exec_timeout
     }
   }
 
   if $restart {
     if $ensure == 'absent' {
       exec { "stop ${title} with docker":
         command     => "${docker_command} stop --time=${stop_wait_time} ${sanitised_title}",
         onlyif      => "${docker_command} inspect ${sanitised_title}",
         environment => $exec_environment,
         path        => $exec_path,
         provider    => $exec_provider,
         timeout     => $exec_timeout
       }
 
       exec { "remove ${title} with docker":
         command     => "${docker_command} rm -v ${sanitised_title}",
         onlyif      => "${docker_command} inspect ${sanitised_title}",
         environment => $exec_environment,
         path        => $exec_path,
         provider    => $exec_provider,
         timeout     => $exec_timeout
       }
 
       file { $cidfile:
         ensure => absent,
       }
     }
     else {
       $run_with_docker_command = [
         "${docker_command} run -d ${docker_run_flags}",
         "--name ${sanitised_title} --cidfile=${cidfile}",
         "--restart=\"${restart}\" ${image} ${command}",
       ]
       $inspect = ["${docker_command} inspect ${sanitised_title}"]
       if $custom_unless {
         $exec_unless = concat($custom_unless, $inspect)
       } else {
         $exec_unless = $inspect
       }
       exec { "run ${title} with docker":
         command     => join($run_with_docker_command, ' '),
         unless      => $exec_unless,
         environment => $exec_environment,
         path        => $exec_path,
         provider    => $exec_provider,
         timeout     => $exec_timeout
       }
 
       if $running == false {
         exec { "stop ${title} with docker":
           command     => "${docker_command} stop --time=${stop_wait_time} ${sanitised_title}",
-          unless      => "${docker_command} inspect ${sanitised_title} -f \"{{ .State.Running }}\" | grep true",
+          onlyif      => $container_running_check,
           environment => $exec_environment,
           path        => $exec_path,
           provider    => $exec_provider,
           timeout     => $exec_timeout
           }
       } else {
         exec { "start ${title} with docker":
           command     => "${docker_command} start ${sanitised_title}",
-          onlyif      => "${docker_command} inspect ${sanitised_title} -f \"{{ .State.Running }}\" | grep false",
+          unless      => $container_running_check,
           environment => $exec_environment,
           path        => $exec_path,
           provider    => $exec_provider,
           timeout     => $exec_timeout
         }
       }
     }
   } else {
 
     $docker_run_inline_start = template('docker/docker-run-start.erb')
     $docker_run_inline_stop = template('docker/docker-run-stop.erb')
 
     case $docker::params::service_provider {
       'systemd': {
         $initscript = "/etc/systemd/system/${service_prefix}${sanitised_title}.service"
         $startscript = "/usr/local/bin/docker-run-${sanitised_title}-start.sh"
         $stopscript = "/usr/local/bin/docker-run-${sanitised_title}-stop.sh"
         $startstop_template = 'docker/usr/local/bin/docker-run.sh.epp'
         $init_template = 'docker/etc/systemd/system/docker-run.erb'
         $mode = '0644'
       }
       'upstart': {
         $initscript = "/etc/init.d/${service_prefix}${sanitised_title}"
         $init_template = 'docker/etc/init.d/docker-run.erb'
         $mode = '0750'
         $startscript = undef
         $stopscript = undef
         $starstop_template = undef
       }
       default: {
         if $::osfamily != 'windows' {
           fail(translate('Docker needs a Debian or RedHat based system.'))
         }
         elsif $ensure == 'present' {
           fail(translate('Restart parameter is required for Windows'))
         }
       }
     }
 
     if $syslog_identifier {
       $_syslog_identifier = $syslog_identifier
     } else {
       $_syslog_identifier = "${service_prefix}${sanitised_title}"
     }
 
     if $ensure == 'absent' {
       if $::osfamily == 'windows'{
         exec {
           "stop container ${service_prefix}${sanitised_title}":
           command     => "${docker_command} stop --time=${stop_wait_time} ${sanitised_title}",
           onlyif      => "${docker_command} inspect ${sanitised_title}",
           environment => $exec_environment,
           path        => $exec_path,
           provider    => $exec_provider,
           timeout     => $exec_timeout,
           notify      => Exec["remove container ${service_prefix}${sanitised_title}"]
         }
       }
       else {
         service { "${service_prefix}${sanitised_title}":
           ensure    => false,
           enable    => false,
           hasstatus => $docker::params::service_hasstatus,
         }
       }
       exec {
         "remove container ${service_prefix}${sanitised_title}":
         command     => "${docker_command} rm -v ${sanitised_title}",
         onlyif      => "${docker_command} inspect ${sanitised_title}",
         environment => $exec_environment,
         path        => $exec_path,
         refreshonly => true,
         provider    => $exec_provider,
         timeout     => $exec_timeout
       }
       if $::osfamily != 'windows' {
         file { "/etc/systemd/system/${service_prefix}${sanitised_title}.service":
           ensure => absent,
           path   => "/etc/systemd/system/${service_prefix}${sanitised_title}.service",
         }
         if ($startscript) {
           file { $startscript:
             ensure => absent
           }
         }
         if ($stopscript) {
           file { $stopscript:
             ensure => absent
           }
         }
       }
       else {
         file { $cidfile:
           ensure => absent,
         }
       }
     }
     else {
       if ($startscript) {
         file { $startscript:
           ensure  => present,
           content => epp($startstop_template, {'script' => $docker_run_inline_start}),
           owner   => 'root',
           group   => $docker_group,
           mode    => '0770'
         }
       }
       if ($stopscript) {
         file { $stopscript:
           ensure  => present,
           content => epp($startstop_template, {'script' => $docker_run_inline_stop}),
           owner   => 'root',
           group   => $docker_group,
           mode    => '0770'
         }
       }
 
       file { $initscript:
         ensure  => present,
         content => template($init_template),
         owner   => 'root',
         group   => $docker_group,
         mode    => $mode,
       }
 
       if $manage_service {
         if $running == false {
           service { "${service_prefix}${sanitised_title}":
             ensure    => $running,
             enable    => false,
             hasstatus => $docker::params::service_hasstatus,
             require   => File[$initscript],
           }
         }
         else {
           # Transition help from moving from CID based container detection to
           # Name-based container detection. See #222 for context.
           # This code should be considered temporary until most people have
           # transitioned. - 2015-04-15
           if $initscript == "/etc/init.d/${service_prefix}${sanitised_title}" {
             # This exec sequence will ensure the old-style CID container is stopped
             # before we replace the init script with the new-style.
             $transition_onlyif = [
               "/usr/bin/test -f /var/run/docker-${sanitised_title}.cid &&",
               "/usr/bin/test -f /etc/init.d/${service_prefix}${sanitised_title}",
             ]
             exec { "/bin/sh /etc/init.d/${service_prefix}${sanitised_title} stop":
               onlyif  => join($transition_onlyif, ' '),
               require => [],
             }
             -> file { "/var/run/${service_prefix}${sanitised_title}.cid":
               ensure => absent,
             }
             -> File[$initscript]
           }
 
           service { "${service_prefix}${sanitised_title}":
             ensure    => $running,
             enable    => true,
             provider  => $docker::params::service_provider,
             hasstatus => $docker::params::service_hasstatus,
             require   => File[$initscript],
           }
         }
 
         if $docker_service {
           if $docker_service == true {
             Service['docker'] -> Service["${service_prefix}${sanitised_title}"]
             if $restart_service_on_docker_refresh == true {
               Service['docker'] ~> Service["${service_prefix}${sanitised_title}"]
             }
           } else {
             Service[$docker_service] -> Service["${service_prefix}${sanitised_title}"]
             if $restart_service_on_docker_refresh == true {
               Service[$docker_service] ~> Service["${service_prefix}${sanitised_title}"]
             }
           }
         }
       }
       if $docker::params::service_provider == 'systemd' {
         exec { "docker-${sanitised_title}-systemd-reload":
           path        => ['/bin/', '/sbin/', '/usr/bin/', '/usr/sbin/'],
           command     => 'systemctl daemon-reload',
           refreshonly => true,
           require     => [File[$initscript],File[$startscript],File[$stopscript]],
           subscribe   => [File[$initscript],File[$startscript],File[$stopscript]]
         }
         Exec["docker-${sanitised_title}-systemd-reload"] -> Service<| title == "${service_prefix}${sanitised_title}" |>
       }
 
       if $restart_service {
         if $startscript or $stopscript {
           [File[$initscript],File[$startscript],File[$stopscript]] ~> Service<| title == "${service_prefix}${sanitised_title}" |>
         }
         else {
           [File[$initscript]] ~> Service<| title == "${service_prefix}${sanitised_title}" |>
         }
       }
       else {
         if $startscript or $stopscript {
           [File[$initscript],File[$startscript],File[$stopscript]] -> Service<| title == "${service_prefix}${sanitised_title}" |>
         }
         else {
           [File[$initscript]] -> Service<| title == "${service_prefix}${sanitised_title}" |>
         }
       }
     }
   }
 }
diff --git a/spec/defines/run_windows_spec.rb b/spec/defines/run_windows_spec.rb
index 5f36865..03afa37 100755
--- a/spec/defines/run_windows_spec.rb
+++ b/spec/defines/run_windows_spec.rb
@@ -1,93 +1,100 @@
 require 'spec_helper'
 
 describe 'docker::run', :type => :define do
   let(:title) { 'sample' }
   let(:pre_condition) { 'class { \'docker\': docker_ee => true }' }
   let(:facts) { {
     :architecture               => 'amd64',
     :osfamily                   => 'windows',
     :operatingsystem            => 'windows',
     :kernelrelease              => '10.0.14393',
     :operatingsystemrelease     => '2016',
     :operatingsystemmajrelease  => '2016',
     :docker_program_data_path   => 'C:/ProgramData',
     :docker_program_files_path  => 'C:/Program Files',
     :docker_systemroot          => 'C:/Windows',
     :docker_user_temp_path      => 'C:/Users/Administrator/AppData/Local/Temp',
     :os                         => { :family => 'windows', :name => 'windows', :release => { :major => '2016', :full => '2016' } }
     } }
   command = 'docker'
 
   context 'with restart policy set to no' do
     let(:params) { {'restart' => 'no', 'command' => 'command', 'image' => 'base', 'extra_parameters' => '-c 4'} }
     it { should contain_exec('run sample with docker') }
     it { should contain_exec('run sample with docker').with_unless(/sample/) }
     it { should contain_exec('run sample with docker').with_unless(/inspect/) }
     it { should contain_exec('run sample with docker').with_command(/--cidfile=C:\/Users\/Administrator\/AppData\/Local\/Temp\/docker-sample.cid/) }
     it { should contain_exec('run sample with docker').with_command(/-c 4/) }
     it { should contain_exec('run sample with docker').with_command(/--restart="no"/) }
     it { should contain_exec('run sample with docker').with_command(/base command/) }
     it { should contain_exec('run sample with docker').with_timeout(3000) }
   end
 
   context 'with restart policy set to always' do
     let(:params) { {'restart' => 'always', 'command' => 'command', 'image' => 'base', 'extra_parameters' => '-c 4'} }
     it { should contain_exec('run sample with docker') }
     it { should contain_exec('run sample with docker').with_unless(/sample/) }
     it { should contain_exec('run sample with docker').with_unless(/inspect/) }
     it { should contain_exec('run sample with docker').with_command(/--cidfile=C:\/Users\/Administrator\/AppData\/Local\/Temp\/docker-sample.cid/) }
     it { should contain_exec('run sample with docker').with_command(/-c 4/) }
     it { should contain_exec('run sample with docker').with_command(/--restart="always"/) }
     it { should contain_exec('run sample with docker').with_command(/base command/) }
     it { should contain_exec('run sample with docker').with_timeout(3000) }
+    it { should contain_exec('start sample with docker').with_command(/docker start sample/) }
   end
 
   context 'with restart policy set to on-failure' do
     let(:params) { {'restart' => 'on-failure', 'command' => 'command', 'image' => 'base', 'extra_parameters' => '-c 4'} }
     it { should contain_exec('run sample with docker') }
     it { should contain_exec('run sample with docker').with_unless(/sample/) }
     it { should contain_exec('run sample with docker').with_unless(/inspect/) }
     it { should contain_exec('run sample with docker').with_command(/--cidfile=C:\/Users\/Administrator\/AppData\/Local\/Temp\/docker-sample.cid/) }
     it { should contain_exec('run sample with docker').with_command(/-c 4/) }
     it { should contain_exec('run sample with docker').with_command(/--restart="on-failure"/) }
     it { should contain_exec('run sample with docker').with_command(/base command/) }
     it { should contain_exec('run sample with docker').with_timeout(3000) }
   end
 
   context 'with restart policy set to on-failure:3' do
     let(:params) { {'restart' => 'on-failure:3', 'command' => 'command', 'image' => 'base', 'extra_parameters' => '-c 4'} }
     it { should contain_exec('run sample with docker') }
     it { should contain_exec('run sample with docker').with_unless(/sample/) }
     it { should contain_exec('run sample with docker').with_unless(/inspect/) }
     it { should contain_exec('run sample with docker').with_command(/--cidfile=C:\/Users\/Administrator\/AppData\/Local\/Temp\/docker-sample.cid/) }
     it { should contain_exec('run sample with docker').with_command(/-c 4/) }
     it { should contain_exec('run sample with docker').with_command(/--restart="on-failure:3"/) }
     it { should contain_exec('run sample with docker').with_command(/base command/) }
     it { should contain_exec('run sample with docker').with_timeout(3000) }
   end
 
   context 'with ensure absent' do
     let(:params) { {'ensure' => 'absent', 'command' => 'command', 'image' => 'base'} }
     it { should compile.with_all_deps }
     it { should contain_exec("stop container docker-sample").with_command('docker stop --time=0 sample') }
     it { should contain_exec("remove container docker-sample").with_command('docker rm -v sample') }
     it { should_not contain_file('C:/Users/Administrator/AppData/Local/Temp/docker-sample.cid"')}
   end
 
   context 'with ensure absent and restart policy' do
     let(:params) { {'ensure' => 'absent', 'command' => 'command', 'image' => 'base', 'restart' => 'always'} }
     it { should compile.with_all_deps }
     it { should contain_exec("stop sample with docker").with_command('docker stop --time=0 sample') }
     it { should contain_exec("remove sample with docker").with_command('docker rm -v sample') }
     it { should_not contain_file('C:/Users/Administrator/AppData/Local/Temp/docker-sample.cid"')}
   end
 
+  context 'with ensure present and running false' do
+    let(:params) { {'ensure' => 'present', 'image' => 'base', 'restart' => 'always', 'running' => false} }
+    it { should compile.with_all_deps }
+    it { should contain_exec("stop sample with docker").with_command('docker stop --time=0 sample') }
+  end
+
   context 'with ensure present and no restart policy' do
     let(:params) { {'ensure' => 'present', 'image' => 'base'} }
     it do
       expect {
         should_not contain_file('C:/Users/Administrator/AppData/Local/Temp/docker-sample.cid"')
       }.to raise_error(Puppet::Error)
     end
   end
 end