chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/provider/user_spec.rb

@@ -261,7 +261,7 @@ describe Chef::Provider::User do
       @provider.action_create
     end
 
-    it "should set the new_resources updated flag when it creates the user if we call manage_user" do
+    it "should set the the new_resources updated flag when it creates the user if we call manage_user" do
       @provider.user_exists = true
       @provider.stub!(:compare_user).and_return(true)
       @provider.stub!(:manage_user).and_return(true)

data/spec/unit/recipe_spec.rb

@@ -24,14 +24,16 @@ require 'spec_helper'
 describe Chef::Recipe do
   before(:each) do
     @cookbook_repo = File.expand_path(File.join(File.dirname(__FILE__), "..", "data", "cookbooks"))
-    @cookbook_collection = Chef::CookbookCollection.new(Chef::CookbookLoader.new(@cookbook_repo))
+    cl = Chef::CookbookLoader.new(@cookbook_repo)
+    cl.load_cookbooks
+    @cookbook_collection = Chef::CookbookCollection.new(cl)
     @node = Chef::Node.new
-    @node[:tags] = Array.new
+    @node.normal[:tags] = Array.new
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
     @recipe = Chef::Recipe.new("hjk", "test", @run_context)
 
-    # Shef/ext.rb is on the run path, and it defines
+    # Shell/ext.rb is on the run path, and it defines
     # Chef::Recipe#resources to call pp, which we don't want when
     # we're running tests.
     @recipe.stub!(:pp)
@@ -108,8 +110,8 @@ describe Chef::Recipe do
 
         it "locate resource for particular platform" do
           Object.const_set('ShaunTheSheep', Class.new(Chef::Resource){ provides :laughter, :on_platforms => ["television"] })
-          @node.platform("television")
-          @node.platform_version("123")
+          @node.automatic[:platform] = "television"
+          @node.automatic[:platform_version] = "123"
           res = @recipe.laughter "timmy"
           res.name.should eql("timmy")
           res.kind_of?(ShaunTheSheep)
@@ -151,7 +153,7 @@ describe Chef::Recipe do
           end
         end
         @run_context.definitions[:crow] = crow_define
-        @node[:foo] = false
+        @node.normal[:foo] = false
         @recipe.crow "mine" do
           something node[:foo]
         end
@@ -204,9 +206,9 @@ describe Chef::Recipe do
       res.pretty_kitty.should eql(true)
     end
 
-    it "should store that it has seen a recipe in node.run_state[:seen_recipes]" do
+    it "should store that it has seen a recipe in the run_context" do
       @run_context.include_recipe "openldap"
-      @node.run_state[:seen_recipes].should have_key("openldap")
+      @run_context.loaded_recipe?("openldap").should be_true
     end
 
     it "should not include the same recipe twice" do

data/spec/unit/registry_helper_spec.rb

@@ -0,0 +1,376 @@
+#
+# Author:: Prajakta Purohit (prajakta@opscode.com)
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::RegistryKey do
+
+  let(:value1) { { :name => "one", :type => :string, :data => "1" } }
+  let(:key_path) { 'HKCU\Software\OpscodeNumbers' }
+  let(:key) { 'Software\OpscodeNumbers' }
+  let(:key_parent) { 'Software' }
+  let(:key_to_delete) { 'OpscodeNumbers' }
+  let(:sub_key) {'OpscodePrimes'}
+  let(:missing_key_path) {'HKCU\Software'}
+
+  before(:each) do
+    Chef::Win32::Registry.any_instance.stub(:machine_architecture).and_return(:x86_64)
+    @registry = Chef::Win32::Registry.new()
+
+    #Making the values for registry constants available on unix
+    Object.send(:remove_const, 'Win32') if defined?(Win32)
+    Win32 = Module.new
+    Win32::Registry = Class.new
+    Win32::Registry::KEY_SET_VALUE = 0x0002
+    Win32::Registry::KEY_QUERY_VALUE = 0x0001
+    Win32::Registry::KEY_WRITE = 0x00020000 | 0x0002 | 0x0004
+    Win32::Registry::KEY_READ = 0x00020000 | 0x0001 | 0x0008 | 0x0010
+
+    Win32::Registry::Error = Class.new(RuntimeError)
+
+    @hive_mock = mock("::Win32::Registry::HKEY_CURRENT_USER")
+    @reg_mock = mock("reg")
+  end
+
+  describe "get_values" do
+    it "gets all values for a key if the key exists" do
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @reg_mock.should_receive(:map)
+      @registry.get_values(key_path)
+    end
+
+    it "throws an exception if key does not exist" do
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      lambda{@registry.get_values(key_path)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+  end
+
+  describe "set_value" do
+    it "does nothing if key and hive and value exist" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
+      @registry.should_receive(:data_exists?).with(key_path, value1).and_return(true)
+      @registry.set_value(key_path, value1)
+    end
+
+    it "updates value if key and hive and value exist, but data is different" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
+      @registry.should_receive(:data_exists?).with(key_path, value1).and_return(false)
+      @hive_mock.should_receive(:open).with(key, Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
+      @reg_mock.should_receive(:write).with("one", 1, "1")
+      @registry.set_value(key_path, value1)
+    end
+
+    it "creates value if the key exists and the value does not exist" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(false)
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
+      @reg_mock.should_receive(:write).with("one", 1, "1")
+      @registry.set_value(key_path, value1)
+    end
+
+    it "should raise an exception if the key does not exist" do
+      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      lambda {@registry.set_value(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+  end
+
+  describe "delete_value" do
+    it "deletes value if value exists" do
+      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_SET_VALUE | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @reg_mock.should_receive(:delete_value).with("one").and_return(true)
+      @registry.delete_value(key_path, value1)
+    end
+
+    it "raises an exception if the key does not exist" do
+      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      @registry.delete_value(key_path, value1)
+    end
+
+    it "does nothing if the value does not exist" do
+      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(false)
+      @registry.delete_value(key_path, value1)
+    end
+  end
+
+  describe "create_key" do
+    it "creates key if intermediate keys are missing and recursive is set to true" do
+      @registry.should_receive(:keys_missing?).with(key_path).and_return(true)
+      @registry.should_receive(:create_missing).with(key_path)
+      @registry.should_receive(:key_exists?).with(key_path).and_return(false)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:create).with(key, ::Win32::Registry::KEY_WRITE | @registry.registry_system_architecture)
+      @registry.create_key(key_path, true)
+    end
+
+    it "raises an exception if intermediate keys are missing and recursive is set to false" do
+      @registry.should_receive(:keys_missing?).with(key_path).and_return(true)
+      lambda{@registry.create_key(key_path, false)}.should raise_error(Chef::Exceptions::Win32RegNoRecursive)
+    end
+
+    it "does nothing if the key exists" do
+      @registry.should_receive(:keys_missing?).with(key_path).and_return(true)
+      @registry.should_receive(:create_missing).with(key_path)
+      @registry.should_receive(:key_exists?).with(key_path).and_return(true)
+      @registry.create_key(key_path, true)
+    end
+
+    it "create key if intermediate keys not missing and recursive is set to false" do
+      @registry.should_receive(:keys_missing?).with(key_path).and_return(false)
+      @registry.should_receive(:key_exists?).with(key_path).and_return(false)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:create).with(key, ::Win32::Registry::KEY_WRITE | @registry.registry_system_architecture)
+      @registry.create_key(key_path, false)
+    end
+
+    it "create key if intermediate keys not missing and recursive is set to true" do
+      @registry.should_receive(:keys_missing?).with(key_path).and_return(false)
+      @registry.should_receive(:key_exists?).with(key_path).and_return(false)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:create).with(key, ::Win32::Registry::KEY_WRITE | @registry.registry_system_architecture)
+      @registry.create_key(key_path, true)
+    end
+  end
+
+  describe "delete_key", :windows_only do
+    it "deletes key if it has subkeys and recursive is set to true" do
+      @registry.should_receive(:key_exists?).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.should_receive(:has_subkeys?).with(key_path).and_return(true)
+      @registry.should_receive(:get_subkeys).with(key_path).and_return([sub_key])
+      @registry.should_receive(:key_exists?).with(key_path+"\\"+sub_key).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path+"\\"+sub_key).and_return([@hive_mock, key+"\\"+sub_key])
+      @registry.should_receive(:has_subkeys?).with(key_path+"\\"+sub_key).and_return(false)
+      @registry.should_receive(:delete_key_ex).twice
+      @registry.delete_key(key_path, true)
+    end
+
+    it "raises an exception if it has subkeys but recursive is set to false" do
+      @registry.should_receive(:key_exists?).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.should_receive(:has_subkeys?).with(key_path).and_return(true)
+      lambda{@registry.delete_key(key_path, false)}.should raise_error(Chef::Exceptions::Win32RegNoRecursive)
+    end
+
+    it "deletes key if the key exists and has no subkeys" do
+      @registry.should_receive(:key_exists?).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.should_receive(:has_subkeys?).with(key_path).and_return(false)
+      @registry.should_receive(:delete_key_ex)
+      @registry.delete_key(key_path, true)
+    end
+  end
+
+  describe "key_exists?" do
+    it "returns true if key_exists" do
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @registry.key_exists?(key_path).should == true
+    end
+
+    it "returns false if key does not exist" do
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_raise(::Win32::Registry::Error)
+      @registry.key_exists?(key_path).should == false
+    end
+  end
+
+  describe "key_exists!" do
+    it "throws an exception if the key_parent does not exist" do
+      @registry.should_receive(:key_exists?).with(key_path).and_return(false)
+      lambda{@registry.key_exists!(key_path)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+  end
+
+  describe "hive_exists?" do
+    it "returns true if the hive exists" do
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.hive_exists?(key_path) == true
+    end
+
+    it "returns false if the hive does not exist" do
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_raise(Chef::Exceptions::Win32RegHiveMissing)
+      @registry.hive_exists?(key_path) == false
+    end
+  end
+
+  describe "has_subkeys?" do
+    it "returns true if the key has subkeys" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @reg_mock.should_receive(:each_key).and_yield(key)
+      @registry.has_subkeys?(key_path) == true
+    end
+
+    it "returns false if the key does not have subkeys" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @reg_mock.should_receive(:each_key).and_return(no_args())
+      @registry.has_subkeys?(key_path).should == false
+    end
+
+    it "throws an exception if the key does not exist" do
+      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      lambda {@registry.set_value(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+  end
+
+  describe "get_subkeys" do
+    it "returns the subkeys if they exist" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @reg_mock.should_receive(:each_key).and_yield(sub_key)
+      @registry.get_subkeys(key_path)
+    end
+  end
+
+  describe "value_exists?" do
+    it "throws an exception if the key does not exist" do
+      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      lambda {@registry.value_exists?(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+
+    it "returns true if the value exists" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @reg_mock.should_receive(:any?).and_yield("one")
+      @registry.value_exists?(key_path, value1) == true
+    end
+
+    it "returns false if the value does not exist" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @reg_mock.should_receive(:any?).and_yield(no_args())
+      @registry.value_exists?(key_path, value1) == false
+    end
+  end
+
+  describe "data_exists?" do
+    it "throws an exception if the key does not exist" do
+      @registry.should_receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      lambda {@registry.data_exists?(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+
+    it "returns true if the data exists" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
+      @reg_mock.should_receive(:each).with(no_args()).and_yield("one", 1, "1")
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @registry.data_exists?(key_path, value1).should == true
+    end
+
+    it "returns false if the data does not exist" do
+      @registry.should_receive(:key_exists!).with(key_path).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
+      @reg_mock.should_receive(:each).with(no_args()).and_yield("one", 1, "2")
+      @registry.data_exists?(key_path, value1).should == false
+    end
+  end
+
+  describe "value_exists!" do
+    it "does nothing if the value exists" do
+      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(true)
+      @registry.value_exists!(key_path, value1)
+    end
+
+    it "throws an exception if the value does not exist" do
+      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(false)
+      lambda{@registry.value_exists!(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegValueMissing)
+    end
+  end
+
+  describe "data_exists!" do
+    it "does nothing if the data exists" do
+      @registry.should_receive(:data_exists?).with(key_path, value1).and_return(true)
+      @registry.data_exists!(key_path, value1)
+    end
+
+    it "throws an exception if the data does not exist" do
+      @registry.should_receive(:data_exists?).with(key_path, value1).and_return(false)
+      lambda{@registry.data_exists!(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegDataMissing)
+    end
+  end
+
+  describe "type_matches?" do
+    it "returns true if type matches" do
+      @registry.should_receive(:value_exists!).with(key_path, value1).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @registry.should_receive(:get_type_from_name).with(:string).and_return(1)
+      @reg_mock.should_receive(:each).and_yield("one", 1)
+      @registry.type_matches?(key_path, value1).should == true
+    end
+
+    it "returns false if type does not match" do
+      @registry.should_receive(:value_exists!).with(key_path, value1).and_return(true)
+      @registry.should_receive(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
+      @hive_mock.should_receive(:open).with(key, ::Win32::Registry::KEY_READ | @registry.registry_system_architecture).and_yield(@reg_mock)
+      @reg_mock.should_receive(:each).and_yield("two", 2)
+      @registry.type_matches?(key_path, value1).should == false
+    end
+
+    it "throws an exception if value does not exist" do
+      @registry.should_receive(:value_exists?).with(key_path, value1).and_return(false)
+      lambda{@registry.type_matches?(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegValueMissing)
+    end
+  end
+
+  describe "type_matches!" do
+    it "does nothing if the type_matches" do
+      @registry.should_receive(:type_matches?).with(key_path, value1).and_return(true)
+      @registry.type_matches!(key_path, value1)
+    end
+
+    it "throws an exception if the type does not match" do
+      @registry.should_receive(:type_matches?).with(key_path, value1).and_return(false)
+      lambda{@registry.type_matches!(key_path, value1)}.should raise_error(Chef::Exceptions::Win32RegTypesMismatch)
+    end
+  end
+
+  describe "keys_missing?" do
+    it "returns true if the keys are missing" do
+      @registry.should_receive(:key_exists?).with(missing_key_path).and_return(false)
+      @registry.keys_missing?(key_path).should == true
+    end
+
+    it "returns false if no keys in the path are missing" do
+      @registry.should_receive(:key_exists?).with(missing_key_path).and_return(true)
+      @registry.keys_missing?(key_path).should == false
+    end
+  end
+end

data/spec/unit/resource/batch_spec.rb

@@ -0,0 +1,48 @@
+#
+# Author:: Adam Edwards (<adamed@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Resource::Batch do
+
+  before(:each) do
+    node = Chef::Node.new
+
+    node.default["kernel"] = Hash.new
+    node.default["kernel"][:machine] = :x86_64.to_s
+
+    run_context = Chef::RunContext.new(node, nil, nil)
+    
+    @resource = Chef::Resource::Batch.new("batch_unit_test", run_context)
+
+  end  
+
+  it "should create a new Chef::Resource::Batch" do
+    @resource.should be_a_kind_of(Chef::Resource::Batch)
+  end
+  
+  context "windows script" do
+    let(:resource_instance) { @resource }
+    let(:resource_instance_name ) { @resource.command }
+    let(:resource_name) { :batch }
+    let(:interpreter_file_name) { 'cmd.exe' }
+
+    it_should_behave_like "a Windows script resource"  
+  end
+  
+end