diff options
Diffstat (limited to 'test/win32ole')
24 files changed, 0 insertions, 3095 deletions
diff --git a/test/win32ole/available_ole.rb b/test/win32ole/available_ole.rb deleted file mode 100644 index af397e00b5..0000000000 --- a/test/win32ole/available_ole.rb +++ /dev/null @@ -1,41 +0,0 @@ -begin - require 'win32ole' -rescue LoadError -end - -if defined?(WIN32OLE) - module AvailableOLE - module_function - - def sysmon_available? - WIN32OLE::Type.new('System Monitor Control', 'SystemMonitor') - true - rescue - false - end - - def ado_available? - WIN32OLE.new('ADODB.Connection') - true - rescue - false - end - - def msxml_available? - !WIN32OLE::TypeLib.typelibs.find { |t| t.name.start_with?('Microsoft XML') }.nil? - end - - def event_param - method = if msxml_available? - typelib = WIN32OLE::TypeLib.typelibs.find { |t| t.name.start_with?('Microsoft XML') } - ole_type = WIN32OLE::Type.new(typelib.name, 'IVBSAXContentHandler') - WIN32OLE::Method.new(ole_type, 'startElement') - elsif ado_available? - typelib = WIN32OLE.new('ADODB.Connection').ole_typelib - ole_type = WIN32OLE::Type.new(typelib.name, 'Connection') - WIN32OLE::Method.new(ole_type, 'WillConnect') - end - method && method.params[0] - end - end -end diff --git a/test/win32ole/err_in_callback.rb b/test/win32ole/err_in_callback.rb deleted file mode 100644 index baecf780b6..0000000000 --- a/test/win32ole/err_in_callback.rb +++ /dev/null @@ -1,10 +0,0 @@ -# frozen_string_literal: false -require 'win32ole' -db = WIN32OLE.new('ADODB.Connection') -db.connectionString = "Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;" -ev = WIN32OLE::Event.new(db) -ev.on_event('WillConnect') {|*args| - foo -} -db.open -WIN32OLE::Event.message_loop diff --git a/test/win32ole/orig_data.csv b/test/win32ole/orig_data.csv deleted file mode 100644 index 3931c6ad1b..0000000000 --- a/test/win32ole/orig_data.csv +++ /dev/null @@ -1,5 +0,0 @@ -ID,VALUE -1,"A" -2,"B" -3,"C" -4,"B" diff --git a/test/win32ole/test_err_in_callback.rb b/test/win32ole/test_err_in_callback.rb deleted file mode 100644 index bea5781bc9..0000000000 --- a/test/win32ole/test_err_in_callback.rb +++ /dev/null @@ -1,56 +0,0 @@ -# frozen_string_literal: false -# -# test Win32OLE avoids cfp consistency error when the exception raised -# in WIN32OLE::Event handler block. [ruby-dev:35450] -# - -begin - require 'win32ole' -rescue LoadError -end -if defined?(WIN32OLE) - require 'mkmf' - require 'pathname' - require 'test/unit' - require 'tmpdir' - class TestErrInCallBack < Test::Unit::TestCase - def setup - @ruby = nil - if File.exist?("./" + CONFIG["RUBY_INSTALL_NAME"] + CONFIG["EXEEXT"]) - sep = File::ALT_SEPARATOR || "/" - @ruby = "." + sep + CONFIG["RUBY_INSTALL_NAME"] - cwd = Pathname.new(File.expand_path('.')) - @iopt = $:.map {|e| - " -I " + (Pathname.new(e).relative_path_from(cwd).to_s rescue e) - }.join("") - script = File.join(File.dirname(__FILE__), "err_in_callback.rb") - @script = Pathname.new(script).relative_path_from(cwd).to_s rescue script - end - end - - def available_adodb? - begin - WIN32OLE.new('ADODB.Connection') - rescue WIN32OLE::RuntimeError - return false - end - return true - end - - def test_err_in_callback - omit "'ADODB.Connection' is not available" unless available_adodb? - if @ruby - Dir.mktmpdir do |tmpdir| - logfile = File.join(tmpdir, "test_err_in_callback.log") - cmd = "#{@ruby} -v #{@iopt} #{@script} > #{logfile.gsub(%r(/), '\\')} 2>&1" - system(cmd) - str = "" - open(logfile) {|ifs| - str = ifs.read - } - assert_match(/NameError/, str) - end - end - end - end -end diff --git a/test/win32ole/test_folderitem2_invokeverb.rb b/test/win32ole/test_folderitem2_invokeverb.rb deleted file mode 100644 index a1c2b2f472..0000000000 --- a/test/win32ole/test_folderitem2_invokeverb.rb +++ /dev/null @@ -1,66 +0,0 @@ -# frozen_string_literal: false -# -# This script check that Win32OLE can execute InvokeVerb method of FolderItem2. -# - -begin - require 'win32ole' -rescue LoadError -end -require 'test/unit' - -if defined?(WIN32OLE) - class TestInvokeVerb < Test::Unit::TestCase - def setup - # make dummy file for InvokeVerb test. - @fso = WIN32OLE.new('Scripting.FileSystemObject') - dummy_file = @fso.GetTempName - @cfolder = @fso.getFolder(".") - f = @cfolder.CreateTextFile(dummy_file) - f.close - @dummy_path = @cfolder.path + "\\" + dummy_file - - shell=WIN32OLE.new('Shell.Application') - @nsp = shell.NameSpace(@cfolder.path) - @fi2 = @nsp.parseName(dummy_file) - end - - def find_link(path) - arlink = [] - @cfolder.files.each do |f| - if /\.lnk$/ =~ f.path - linkinfo = @nsp.parseName(f.name).getLink - arlink.push f if linkinfo.path == path - end - end - arlink - end - - def test_invokeverb - # in Windows Vista (not tested), Windows 7 - # The verb must be in English. - # Creating Shortcut is "Link" - links = find_link(@dummy_path) - assert_equal(0, links.size) - - # Now create shortcut to @dummy_path - arg = WIN32OLE::Variant.new("Link") - @fi2.InvokeVerb(arg) - - # Now search shortcut to @dummy_path - links = find_link(@dummy_path) - assert_equal(1, links.size) - @lpath = links[0].path - end - - def teardown - if @lpath - @fso.deleteFile(@lpath) - end - if @dummy_path - @fso.deleteFile(@dummy_path) - end - end - - end -end diff --git a/test/win32ole/test_nil2vtempty.rb b/test/win32ole/test_nil2vtempty.rb deleted file mode 100644 index bd86403676..0000000000 --- a/test/win32ole/test_nil2vtempty.rb +++ /dev/null @@ -1,37 +0,0 @@ -# frozen_string_literal: false -# This is test script to check that WIN32OLE should convert nil to VT_EMPTY in second try. -# [ruby-talk:137054] -begin - require 'win32ole' -rescue LoadError -end -require 'test/unit' - -if defined?(WIN32OLE) - class TestNIL2VT_EMPTY < Test::Unit::TestCase - def setup - fs = WIN32OLE.new('Scripting.FileSystemObject') - @path = fs.GetFolder(".").path - end - def test_openSchema - con = nil - begin - con = WIN32OLE.new('ADODB.Connection') - con.connectionString = "Provider=MSDASQL;Extended Properties=" - con.connectionString +="\"DRIVER={Microsoft Text Driver (*.txt; *.csv)};DBQ=#{@path}\"" - con.open - rescue - con = nil - end - if con - rs = con.openSchema(4, [nil,nil,"DUMMY", "TABLE"]) - assert(rs) - assert_equal("_Recordset", rs.ole_type.name) - - rs = con.openSchema(4, [WIN32OLE::Variant::Empty, WIN32OLE::Variant::Empty, "DUMMY", "TABLE"]) - assert(rs) - assert_equal("_Recordset", rs.ole_type.name) - end - end - end -end diff --git a/test/win32ole/test_ole_methods.rb b/test/win32ole/test_ole_methods.rb deleted file mode 100644 index fbade04e48..0000000000 --- a/test/win32ole/test_ole_methods.rb +++ /dev/null @@ -1,35 +0,0 @@ -# frozen_string_literal: false -# -# This is test for [ruby-talk:196897] -# -begin - require 'win32ole' -rescue LoadError -end -require "test/unit" - -if defined?(WIN32OLE) - class TestWIN32OLE_FOR_PROPERTYPUTREF < Test::Unit::TestCase - - def setup - @obj = WIN32OLE.new('Scripting.Dictionary') - end - - def test_ole_methods - x = @obj.ole_methods.select {|m| - m.invoke_kind == 'PROPERTYPUTREF' - } - assert_equal(1, x.size) - assert_equal('Item', x[0].name) - end - - def test_ole_put_methods - x = @obj.ole_put_methods.select {|m| - m.invoke_kind == 'PROPERTYPUTREF' - } - assert_equal(1, x.size) - assert_equal('Item', x[0].name) - end - - end -end diff --git a/test/win32ole/test_propertyputref.rb b/test/win32ole/test_propertyputref.rb deleted file mode 100644 index 83418140c2..0000000000 --- a/test/win32ole/test_propertyputref.rb +++ /dev/null @@ -1,31 +0,0 @@ -# frozen_string_literal: false -require 'test/unit' -begin - require 'win32ole' -rescue LoadError -end - -if defined?(WIN32OLE) - class TestWIN32OLE_PROPERTYPUTREF < Test::Unit::TestCase - def setup - begin - @sapi = WIN32OLE.new('SAPI.SpVoice') - @sv = @sapi.voice - rescue WIN32OLE::RuntimeError - @sapi = nil - end - end - def test_sapi - if @sapi - new_id = @sapi.getvoices.item(0).Id - @sapi.voice = @sapi.getvoices.item(0) - assert_equal(new_id, @sapi.voice.Id) - end - end - def teardown - if @sapi - @sapi.voice = @sv - end - end - end -end diff --git a/test/win32ole/test_thread.rb b/test/win32ole/test_thread.rb deleted file mode 100644 index b30b2349c5..0000000000 --- a/test/win32ole/test_thread.rb +++ /dev/null @@ -1,34 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require 'test/unit' - -if defined?(WIN32OLE) - class TestWIN32OLE_THREAD < Test::Unit::TestCase - # - # test for Bug #2618(ruby-core:27634) - # - def assert_creating_win32ole_object_in_thread(meth) - t = Thread.__send__(meth) { - WIN32OLE.new('Scripting.Dictionary') - } - assert_nothing_raised(WIN32OLE::RuntimeError, "[Bug #2618] Thread.#{meth}") { - t.join - } - end - - def test_creating_win32ole_object_in_thread_new - assert_creating_win32ole_object_in_thread(:new) - end - - def test_creating_win32ole_object_in_thread_start - assert_creating_win32ole_object_in_thread(:start) - end - - def test_creating_win32ole_object_in_thread_fork - assert_creating_win32ole_object_in_thread(:fork) - end - end -end diff --git a/test/win32ole/test_win32ole.rb b/test/win32ole/test_win32ole.rb deleted file mode 100644 index b0c147b311..0000000000 --- a/test/win32ole/test_win32ole.rb +++ /dev/null @@ -1,536 +0,0 @@ -# coding: us-ascii -# frozen_string_literal: false - -begin - require 'win32ole' -rescue LoadError -end -require 'test/unit' - -if defined?(WIN32OLE) - module CONST1 - end - module CONST2 - end - - module TestCaseForDict - def test_convert_bignum - @dict1.add("a", 9999999999) - @dict1.add("b", 999999999) - @dict1.add("c", @dict1.item("b") * 10 + 9) - assert_equal(9999999999, @dict1.item("a")) - assert_equal(9999999999, @dict1.item("c")) - end - def test_add - @dict1.add("a", 1000) - assert_equal(1000, @dict1.item("a")) - end - def test_setproperty_equal_ended - @dict1.compareMode = 1 - @dict1.add("one", 1) - assert_equal(1, @dict1.item("ONE")) - @dict2.add("one", 1) - assert_nil(@dict2.item("ONE")) - assert_equal(1, @dict2.item("one")) - end - def test_non_exist_property - assert_raise(WIN32OLE::RuntimeError) { - @dict1.unknown_property = 1 - } - end - - def test_raise_message - exc = assert_raise(WIN32OLE::RuntimeError) { - @dict1.add - } - assert_match(/^\(in OLE method `add': \)/, exc.message) #` - - exc = assert_raise(WIN32OLE::RuntimeError) { - @dict1._invoke(1, [], []) - } - assert_match(/^\(in OLE method `<dispatch id:1>': \)/, exc.message) #` - - exc = assert_raise(WIN32OLE::RuntimeError) { - @dict1.compareMode = -1 - } - assert_match(/^\(in setting property `compareMode': \)/, exc.message) #` - end - - def test_no_method_error - exc = assert_raise(NoMethodError) { - @dict1.non_exist_method - } - assert_match(/non_exist_method/, exc.message) - assert_kind_of(WIN32OLE, exc.receiver) - end - - def test_ole_methods - methods = @dict1.ole_methods - mnames = methods.collect {|m| - m.name - } - assert_include(mnames, 'Add') - end - - def test_methods - methods = @dict1.methods - assert_include(methods, :Add) - end - - def test_ole_func_methods - methods = @dict1.ole_func_methods - mnames = methods.collect {|m| - m.name - } - assert_include(mnames, 'Add') - end - - def test_ole_put_methods - methods = @dict1.ole_put_methods - mnames = methods.collect {|m| - m.name - } - assert_include(mnames, 'CompareMode') - end - - def test_ole_get_methods - methods = @dict1.ole_get_methods - mnames = methods.collect {|m| - m.name - } - assert_include(mnames, 'Count') - end - - def test_ole_method_help - minfo = @dict1.ole_method_help("Add") - assert_equal(2, minfo.size_params) - end - - def test_ole_typelib - tlib = @dict1.ole_typelib - assert_equal("Microsoft Scripting Runtime", tlib.name); - end - - def test_each - @dict1.add("one", 1) - @dict1.add("two", 2) - i = 0 - @dict1.keys.each do |item| - i += 1 - end - assert_equal(2, i) - end - - def test_bracket - @dict1.add("foo", "FOO") - assert_equal("FOO", @dict1.item("foo")) - assert_equal("FOO", @dict1["foo"]) - end - - def test_bracket_equal - @dict1.add("foo", "FOO") - @dict1["foo"] = "BAR" - assert_equal("BAR", @dict1["foo"]) - end - - def test_bracket_with_numkey - @dict1.add(1, "ONE") - @dict1.add(2, "two") - assert_equal("ONE", @dict1[1]) - @dict1[2] = "TWO" - assert_equal("TWO", @dict1[2]) - end - - def test_invoke_with_array - @dict1.add("ary1", [1,2,3]) - assert_equal([1,2,3], @dict1["ary1"]) - - @dict1.add("ary2", [[1,2,"a"], [3,4,"b"]]) - assert_equal([[1,2,"a"], [3,4,"b"]], @dict1["ary2"]) - - @dict1.add("ary3", [[[1]]]) - assert_equal([[[1]]], @dict1["ary3"]) - - @dict1.add("ary4", [[[1], [2], [3]], [[4], [5], [6]]]) - assert_equal([[[1],[2], [3]], [[4], [5], [6]]], @dict1["ary4"]) - end - end - - class TestWin32OLE < Test::Unit::TestCase - include TestCaseForDict - def setup - @dict1 = WIN32OLE.new('Scripting.Dictionary') - @dict2 = WIN32OLE.new('Scripting.Dictionary') - end - def test_s_new - assert_instance_of(WIN32OLE, @dict1) - assert_instance_of(WIN32OLE, @dict2) - end - - def test_s_new_exc - assert_raise(TypeError) { - WIN32OLE.new(1) - } - assert_raise(TypeError) { - WIN32OLE.new("Scripting.Dictionary", 1) - } - end - - def test_s_new_DCOM - rshell = WIN32OLE.new("Shell.Application") - assert_instance_of(WIN32OLE, rshell) - end - - def test_s_new_from_clsid - shell = WIN32OLE.new("{13709620-C279-11CE-A49E-444553540000}") - assert_instance_of(WIN32OLE, shell) - exc = assert_raise(WIN32OLE::RuntimeError) { - WIN32OLE.new("{000}") - } - assert_match(/unknown OLE server: `\{000\}'/, exc.message) #` - end - - def test_s_connect - obj = WIN32OLE.connect("winmgmts:") - assert_instance_of(WIN32OLE, obj) - end - - def test_s_connect_exc - assert_raise(TypeError) { - WIN32OLE.connect(1) - } - end - - def test_invoke_accept_symbol_hash_key - fso = WIN32OLE.new('Scripting.FileSystemObject') - afolder = fso.getFolder(".") - bfolder = fso.getFolder({"FolderPath" => "."}) - cfolder = fso.getFolder({:FolderPath => "."}) - assert_equal(afolder.path, bfolder.path) - assert_equal(afolder.path, cfolder.path) - fso = nil - end - - def test_setproperty - installer = WIN32OLE.new("WindowsInstaller.Installer") - record = installer.CreateRecord(2) - # this is the way to set property with argument in Win32OLE. - record.setproperty( "StringData", 1, 'dddd') - assert_equal('dddd', record.StringData(1)) - end - - def test_ole_type - fso = WIN32OLE.new('Scripting.FileSystemObject') - tobj = fso.ole_type - assert_match(/^IFileSystem/, tobj.name) - end - - def test_ole_obj_help - fso = WIN32OLE.new('Scripting.FileSystemObject') - tobj = fso.ole_obj_help - assert_match(/^IFileSystem/, tobj.name) - end - - - def test_invoke_hash_key_non_str_sym - fso = WIN32OLE.new('Scripting.FileSystemObject') - begin - fso.getFolder({1 => "."}) - assert(false) - rescue TypeError - assert(true) - end - fso = nil - end - - def test_get_win32ole_object - shell = WIN32OLE.new('Shell.Application') - folder = shell.nameSpace(0) - assert_instance_of(WIN32OLE, folder) - end - - def test_invoke_accept_multi_hash_key - shell = WIN32OLE.new('Shell.Application') - folder = shell.nameSpace(0) - item = folder.items.item(0) - name = folder.getDetailsOf(item, 0) - assert_equal(item.name, name) - name = folder.getDetailsOf({:vItem => item, :iColumn => 0}) - assert_equal(item.name, name) - name = folder.getDetailsOf({"vItem" => item, :iColumn => 0}) - assert_equal(item.name, name) - end - - def test_ole_invoke_with_named_arg_last - shell = WIN32OLE.new('Shell.Application') - folder = shell.nameSpace(0) - item = folder.items.item(0) - name = folder.getDetailsOf(item, {:iColumn => 0}) - assert_equal(item.name, name) - end - - def test__invoke - shell=WIN32OLE.new('Shell.Application') - assert_equal(shell.NameSpace(0).title, shell._invoke(0x60020002, [0], [WIN32OLE::VARIANT::VT_VARIANT]).title) - end - - def test_ole_query_interface - shell=WIN32OLE.new('Shell.Application') - assert_raise(ArgumentError) { - shell.ole_query_interface - } - assert_raise(TypeError) { - shell.ole_query_interface(0x11223344) - } - shell2 = shell.ole_query_interface('{A4C6892C-3BA9-11D2-9DEA-00C04FB16162}') - assert_instance_of(WIN32OLE, shell2) - end - - def test_ole_respond_to - fso = WIN32OLE.new('Scripting.FileSystemObject') - assert(fso.ole_respond_to?('getFolder')) - assert(fso.ole_respond_to?('GETFOLDER')) - assert(fso.ole_respond_to?(:getFolder)) - assert(!fso.ole_respond_to?('XXXXX')) - assert_raise(TypeError) { - assert_raise(fso.ole_respond_to?(1)) - } - end - - def test_invoke - fso = WIN32OLE.new('Scripting.FileSystemObject') - assert(fso.invoke(:getFolder, ".")) - assert(fso.invoke('getFolder', ".")) - end - - def test_s_const_load - assert(!defined?(CONST1::SsfWINDOWS)) - shell=WIN32OLE.new('Shell.Application') - WIN32OLE.const_load(shell, CONST1) - assert_equal(36, CONST1::SsfWINDOWS) - - assert(!defined?(CONST2::SsfWINDOWS)) - WIN32OLE.const_load("Microsoft Shell Controls And Automation", CONST2) - assert_equal(36, CONST2::SsfWINDOWS) - end - - def test_s_create_guid - guid = WIN32OLE.create_guid - assert_match(/^\{[A-Z0-9]{8}\-[A-Z0-9]{4}\-[A-Z0-9]{4}\-[A-Z0-9]{4}\-[A-Z0-9]{12}/, - guid) - end - - # - # WIN32OLE.codepage is initialized according to Encoding.default_external. - # - # def test_s_codepage - # assert_equal(WIN32OLE::CP_ACP, WIN32OLE.codepage) - # end - - def test_s_codepage_set - cp = WIN32OLE.codepage - WIN32OLE.codepage = WIN32OLE::CP_UTF8 - assert_equal(WIN32OLE::CP_UTF8, WIN32OLE.codepage) - WIN32OLE.codepage = cp - end - - def test_s_codepage_changed - omit if RUBY_PLATFORM.match("mswin") - - cp = WIN32OLE.codepage - fso = WIN32OLE.new("Scripting.FileSystemObject") - fname = fso.getTempName - begin - obj = WIN32OLE::Variant.new([0x3042].pack("U*").force_encoding("UTF-8")) - WIN32OLE.codepage = WIN32OLE::CP_UTF8 - assert_equal("\xE3\x81\x82".force_encoding("CP65001"), obj.value) - - begin - WIN32OLE.codepage = 932 # Windows-31J - rescue WIN32OLE::RuntimeError - end - if (WIN32OLE.codepage == 932) - assert_equal("\x82\xA0".force_encoding("CP932"), obj.value) - end - - begin - WIN32OLE.codepage = 20932 # MS EUC-JP - rescue WIN32OLE::RuntimeError - end - if (WIN32OLE.codepage == 20932) - assert_equal("\xA4\xA2".force_encoding("CP20932"), obj.value) - end - - WIN32OLE.codepage = cp - file = fso.opentextfile(fname, 2, true) - test_str = [0x3042].pack("U*").encode("UTF-16LE") - begin - file.write test_str.force_encoding("UTF-16") - ensure - file.close - end - str = "" - open(fname, "r:ascii-8bit") {|ifs| - str = ifs.read - } - assert_equal(test_str.force_encoding("ascii-8bit"), str) - - # This test fail if codepage 20932 (euc) is not installed. - begin - WIN32OLE.codepage = 20932 - rescue WIN32OLE::RuntimeError - end - if (WIN32OLE.codepage == 20932) - WIN32OLE.codepage = cp - file = fso.opentextfile(fname, 2, true) - begin - file.write [164, 162].pack("c*").force_encoding("UTF-16") - ensure - file.close - end - open(fname, "r:ascii-8bit") {|ifs| - str = ifs.read - } - assert_equal("\244\242", str) - end - - ensure - WIN32OLE.codepage = cp - if (File.exist?(fname)) - File.unlink(fname) - end - end - end - - def test_cp51932 - cp = WIN32OLE.codepage - begin - obj = WIN32OLE::Variant.new([0x3042].pack("U*").force_encoding("UTF-8")) - begin - WIN32OLE.codepage = 51932 - rescue - end - if WIN32OLE.codepage == 51932 - assert_equal("\xA4\xA2".force_encoding("CP51932"), obj.value) - end - ensure - WIN32OLE.codepage = cp - end - end - - def test_s_locale - assert_equal(WIN32OLE::LOCALE_SYSTEM_DEFAULT, WIN32OLE.locale) - end - - def test_s_locale_set - begin - begin - WIN32OLE.locale = 1041 - rescue WIN32OLE::RuntimeError - STDERR.puts("\n#{__FILE__}:#{__LINE__}:#{self.class.name}.test_s_locale_set is skipped(Japanese locale is not installed)") - return - end - assert_equal(1041, WIN32OLE.locale) - WIN32OLE.locale = WIN32OLE::LOCALE_SYSTEM_DEFAULT - assert_raise(WIN32OLE::RuntimeError) { - WIN32OLE.locale = 111 - } - assert_equal(WIN32OLE::LOCALE_SYSTEM_DEFAULT, WIN32OLE.locale) - ensure - WIN32OLE.locale = WIN32OLE::LOCALE_SYSTEM_DEFAULT - end - end - - def test_s_locale_change - begin - begin - WIN32OLE.locale = 0x0411 - rescue WIN32OLE::RuntimeError - end - if WIN32OLE.locale == 0x0411 - obj = WIN32OLE::Variant.new("\\100,000", WIN32OLE::VARIANT::VT_CY) - assert_equal("100000", obj.value) - assert_raise(WIN32OLE::RuntimeError) { - obj = WIN32OLE::Variant.new("$100.000", WIN32OLE::VARIANT::VT_CY) - } - else - STDERR.puts("\n#{__FILE__}:#{__LINE__}:#{self.class.name}.test_s_locale_change is skipped(Japanese locale is not installed)") - end - - begin - WIN32OLE.locale = 1033 - rescue WIN32OLE::RuntimeError - end - if WIN32OLE.locale == 1033 - obj = WIN32OLE::Variant.new("$100,000", WIN32OLE::VARIANT::VT_CY) - assert_equal("100000", obj.value) - else - STDERR.puts("\n#{__FILE__}:#{__LINE__}:#{self.class.name}.test_s_locale_change is skipped(US English locale is not installed)") - end - ensure - WIN32OLE.locale = WIN32OLE::LOCALE_SYSTEM_DEFAULT - end - end - - def test_const_CP_ACP - assert_equal(0, WIN32OLE::CP_ACP) - end - - def test_const_CP_OEMCP - assert_equal(1, WIN32OLE::CP_OEMCP) - end - - def test_const_CP_MACCP - assert_equal(2, WIN32OLE::CP_MACCP) - end - - def test_const_CP_THREAD_ACP - assert_equal(3, WIN32OLE::CP_THREAD_ACP) - end - - def test_const_CP_SYMBOL - assert_equal(42, WIN32OLE::CP_SYMBOL) - end - - def test_const_CP_UTF7 - assert_equal(65000, WIN32OLE::CP_UTF7) - end - - def test_const_CP_UTF8 - assert_equal(65001, WIN32OLE::CP_UTF8) - end - - def test_const_LOCALE_SYSTEM_DEFAULT - assert_equal(0x0800, WIN32OLE::LOCALE_SYSTEM_DEFAULT); - end - - def test_const_LOCALE_USER_DEFAULT - assert_equal(0x0400, WIN32OLE::LOCALE_USER_DEFAULT); - end - - def test_method_missing - assert_raise(ArgumentError) {@dict1.method_missing} - assert_raise(TypeError) {@dict1.method_missing(1)} - assert_raise(ArgumentError) {@dict1.method_missing("foo=")} - assert_raise(ArgumentError) {@dict1.method_missing("foo=", 1, 2)} - end - end - - # test of subclass of WIN32OLE - class MyDict < WIN32OLE - def MyDict.new - super('Scripting.Dictionary') - end - end - class TestMyDict < Test::Unit::TestCase - include TestCaseForDict - def setup - @dict1 = MyDict.new - @dict2 = MyDict.new - end - def test_s_new - assert_instance_of(MyDict, @dict1) - assert_instance_of(MyDict, @dict2) - end - end -end diff --git a/test/win32ole/test_win32ole_event.rb b/test/win32ole/test_win32ole_event.rb deleted file mode 100644 index da3ee8567e..0000000000 --- a/test/win32ole/test_win32ole_event.rb +++ /dev/null @@ -1,407 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require 'test/unit' - -ado_installed = - if defined?(WIN32OLE) - db = nil - begin - db = WIN32OLE.new('ADODB.Connection') - db.connectionString = "Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;" - db.open - db.close - db = nil - true - rescue - end - end - -swbemsink_available = - if defined?(WIN32OLE) - begin - WIN32OLE.new('WbemScripting.SWbemSink') - true - rescue - end - end - -if defined?(WIN32OLE::Event) - class TestWIN32OLE_EVENT < Test::Unit::TestCase - def test_s_new_exception - assert_raise(TypeError) { - WIN32OLE::Event.new("A") - } - end - def test_s_new_non_exist_event - dict = WIN32OLE.new('Scripting.Dictionary') - assert_raise(RuntimeError) { - WIN32OLE::Event.new(dict) - } - end - end - - if swbemsink_available - class TestWIN32OLE_EVENT_SWbemSink < Test::Unit::TestCase - def setup - @wmi = WIN32OLE.connect('winmgmts://localhost/root/cimv2') - @sws = WIN32OLE.new('WbemScripting.SWbemSink') - @event = @event1 = @event2 = "" - @sql = "SELECT * FROM __InstanceModificationEvent WITHIN 1 WHERE TargetInstance ISA 'Win32_LocalTime'" - end - - def message_loop(watch_ivar = nil) - if watch_ivar - orig_ivar = instance_variable_get(watch_ivar) - end - - 2.times do - WIN32OLE::Event.message_loop - sleep 1 - end - - if watch_ivar - # wait until event is proceeded - tries = 0 - seconds = EnvUtil.apply_timeout_scale(1) - while tries < 5 && instance_variable_get(watch_ivar) == orig_ivar - $stderr.puts "test_win32ole_event.rb: retrying and sleeping #{seconds}s until #{watch_ivar} is changed from #{orig_ivar.inspect}..." - WIN32OLE::Event.message_loop - sleep(seconds) - tries += 1 - seconds *= 2 # sleep at most 31s in total - end - end - end - - def default_handler(event, *args) - @event += event - end - - def handler1 - @event1 = "handler1" - end - - def test_s_new_non_exist_event - assert_raise(RuntimeError) { - WIN32OLE::Event.new(@sws, 'XXXXX') - } - end - - def test_s_new - obj = WIN32OLE::Event.new(@sws, 'ISWbemSinkEvents') - assert_instance_of(WIN32OLE::Event, obj) - obj = WIN32OLE::Event.new(@sws) - assert_instance_of(WIN32OLE::Event, obj) - end - - def test_s_new_loop - exec_notification_query_async - ev = WIN32OLE::Event.new(@sws) - ev.on_event {|*args| default_handler(*args)} - message_loop - 10.times do |i| - WIN32OLE::Event.new(@sws) - message_loop - GC.start - end - - # @event randomly becomes "OnCompleted" here. Try to wait until it matches. - # https://ci.appveyor.com/project/ruby/ruby/builds/19963142/job/8gaxepksa0i3b998 - assert_match_with_retries(/OnObjectReady/, :@event) - end - - def test_on_event - exec_notification_query_async - ev = WIN32OLE::Event.new(@sws, 'ISWbemSinkEvents') - ev.on_event {|*args| default_handler(*args)} - message_loop(:@event) - assert_match(/OnObjectReady/, @event) - end - - def test_on_event_symbol - exec_notification_query_async - ev = WIN32OLE::Event.new(@sws) - ev.on_event(:OnObjectReady) {|*args| - handler1 - } - message_loop(:@event1) - assert_equal("handler1", @event1) - end - - private - def exec_notification_query_async - @wmi.ExecNotificationQueryAsync(@sws, @sql) - rescue => e - if /OLE error code:80041008 in SWbemServicesEx/ =~ e.message - omit "No administrator privilege?" - end - raise - end - - def assert_match_with_retries(regexp, ivarname) - ivar = instance_variable_get(ivarname) - - tries = 0 - while tries < 6 && !ivar.match(regexp) - $stderr.puts "test_win32ole_event.rb: retrying until #{ivarname} (#{ivar}) matches #{regexp} (tries: #{tries})..." - sleep(2 ** tries) # sleep at most 63s in total - ivar = instance_variable_get(ivarname) - tries += 1 - end - - assert_match(regexp, ivar) - end - end - end - - if ado_installed - class TestWIN32OLE_EVENT_ADO < Test::Unit::TestCase - CONNSTR="Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;" - module ADO - end - def message_loop - WIN32OLE::Event.message_loop - end - - def default_handler(event, *args) - @event += event - end - - def setup - @db = WIN32OLE.new('ADODB.Connection') - if !defined?(ADO::AdStateOpen) - WIN32OLE.const_load(@db, ADO) - end - @db.connectionString = CONNSTR - @event = "" - @event2 = "" - @event3 = "" - end - - def test_on_event2 - ev = WIN32OLE::Event.new(@db, 'ConnectionEvents') - ev.on_event('WillConnect') {|*args| handler1} - ev.on_event('WillConnect') {|*args| handler2} - @db.open - message_loop - assert_equal("handler2", @event2) - end - - def test_on_event4 - ev = WIN32OLE::Event.new(@db, 'ConnectionEvents') - ev.on_event{|*args| handler1} - ev.on_event{|*args| handler2} - ev.on_event('WillConnect'){|*args| handler3(*args)} - @db.open - message_loop - assert_equal(CONNSTR, @event3) - assert("handler2", @event2) - end - - def test_on_event5 - ev = WIN32OLE::Event.new(@db, 'ConnectionEvents') - ev.on_event {|*args| default_handler(*args)} - ev.on_event('WillConnect'){|*args| handler3(*args)} - @db.open - message_loop - assert_match(/ConnectComplete/, @event) - assert(/WillConnect/ !~ @event) - assert_equal(CONNSTR, @event3) - end - - def test_unadvise - ev = WIN32OLE::Event.new(@db, 'ConnectionEvents') - ev.on_event {|*args| default_handler(*args)} - @db.open - message_loop - assert_match(/WillConnect/, @event) - ev.unadvise - @event = "" - @db.close - @db.open - message_loop - assert_equal("", @event); - assert_raise(WIN32OLE::RuntimeError) { - ev.on_event {|*args| default_handler(*args)} - } - end - - - def test_on_event_with_outargs - ev = WIN32OLE::Event.new(@db) - @db.connectionString = 'XXX' # set illegal connection string - assert_raise(WIN32OLE::RuntimeError) { - @db.open - } - ev.on_event_with_outargs('WillConnect'){|*args| - args.last[0] = CONNSTR # ConnectionString = CONNSTR - } - @db.open - message_loop - assert(true) - end - - def test_on_event_hash_return - ev = WIN32OLE::Event.new(@db) - ev.on_event('WillConnect'){|*args| - {:return => 1, :ConnectionString => CONNSTR} - } - @db.connectionString = 'XXX' - @db.open - assert(true) - end - - def test_on_event_hash_return2 - ev = WIN32OLE::Event.new(@db) - ev.on_event('WillConnect'){|*args| - {:ConnectionString => CONNSTR} - } - @db.connectionString = 'XXX' - @db.open - assert(true) - end - - def test_on_event_hash_return3 - ev = WIN32OLE::Event.new(@db) - ev.on_event('WillConnect'){|*args| - {'ConnectionString' => CONNSTR} - } - @db.connectionString = 'XXX' - @db.open - assert(true) - end - - def test_on_event_hash_return4 - ev = WIN32OLE::Event.new(@db) - ev.on_event('WillConnect'){|*args| - {'return' => 1, 'ConnectionString' => CONNSTR} - } - @db.connectionString = 'XXX' - @db.open - assert(true) - end - - def test_on_event_hash_return5 - ev = WIN32OLE::Event.new(@db) - ev.on_event('WillConnect'){|*args| - {0 => CONNSTR} - } - @db.connectionString = 'XXX' - @db.open - assert(true) - end - - def test_off_event - ev = WIN32OLE::Event.new(@db) - ev.on_event{handler1} - ev.off_event - @db.open - message_loop - assert_equal("", @event2) - end - - def test_off_event_arg - ev = WIN32OLE::Event.new(@db) - ev.on_event('WillConnect'){handler1} - ev.off_event('WillConnect') - @db.open - message_loop - assert_equal("", @event2) - end - - def test_off_event_arg2 - ev = WIN32OLE::Event.new(@db) - ev.on_event('WillConnect'){handler1} - ev.on_event('ConnectComplete'){handler1} - ev.off_event('WillConnect') - @db.open - message_loop - assert_equal("handler1", @event2) - end - - def test_off_event_sym_arg - ev = WIN32OLE::Event.new(@db) - ev.on_event('WillConnect'){handler1} - ev.off_event(:WillConnect) - @db.open - message_loop - assert_equal("", @event2) - end - - def handler1 - @event2 = "handler1" - end - - def handler2 - @event2 = "handler2" - end - - def handler3(*arg) - @event3 += arg[0] - end - - def teardown - if @db && @db.state == ADO::AdStateOpen - @db.close - end - message_loop - @db = nil - end - - class Handler1 - attr_reader :val1, :val2, :val3, :val4 - def initialize - @val1 = nil - @val2 = nil - @val3 = nil - @val4 = nil - end - def onWillConnect(conn, uid, pwd, opts, stat, pconn) - @val1 = conn - end - def onConnectComplete(err, stat, pconn) - @val2 = err - @val3 = stat - end - def onInfoMessage(err, stat, pconn) - @val4 = stat - end - end - - class Handler2 - attr_reader :ev - def initialize - @ev = "" - end - def method_missing(ev, *arg) - @ev += ev - end - end - - def test_handler1 - ev = WIN32OLE::Event.new(@db) - h1 = Handler1.new - ev.handler = h1 - @db.open - message_loop - assert_equal(CONNSTR, h1.val1) - assert_equal(h1.val1, ev.handler.val1) - assert_equal(nil, h1.val2) - assert_equal(ADO::AdStateOpen, h1.val3) - assert_equal(ADO::AdStateOpen, h1.val4) - end - - def test_handler2 - ev = WIN32OLE::Event.new(@db) - h2 = Handler2.new - ev.handler = h2 - @db.open - message_loop - assert(h2.ev != "") - end - end - end -end diff --git a/test/win32ole/test_win32ole_method.rb b/test/win32ole/test_win32ole_method.rb deleted file mode 100644 index 4b3e255fdc..0000000000 --- a/test/win32ole/test_win32ole_method.rb +++ /dev/null @@ -1,134 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require "test/unit" - -if defined?(WIN32OLE::Method) - class TestWIN32OLE_METHOD < Test::Unit::TestCase - - def setup - ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Shell") - @m_open = WIN32OLE::Method.new(ole_type, "open") - @m_namespace = WIN32OLE::Method.new(ole_type, "namespace") - @m_parent = WIN32OLE::Method.new(ole_type, "parent") - @m_invoke = WIN32OLE::Method.new(ole_type, "invoke") - @m_browse_for_folder = WIN32OLE::Method.new(ole_type, "BrowseForFolder") - - ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "File") - @m_file_name = WIN32OLE::Method.new(ole_type, "name") - end - - def test_initialize - ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Shell") - assert_raise(TypeError) { - WIN32OLE::Method.new(1, 2) - } - assert_raise(ArgumentError) { - WIN32OLE::Method.new("foo") - } - assert_raise(ArgumentError) { - WIN32OLE::Method.new(ole_type) - } - assert_raise(WIN32OLE::RuntimeError) { - WIN32OLE::Method.new(ole_type, "NonExistMethod") - } - assert_raise(TypeError) { - WIN32OLE::Method.new(ole_type, 1) - } - method = WIN32OLE::Method.new(ole_type, "Open") - assert_instance_of(WIN32OLE::Method, method) - method = WIN32OLE::Method.new(ole_type, "open") - assert_instance_of(WIN32OLE::Method, method) - end - - def test_name - assert_equal("Open", @m_open.name) - end - - def test_return_type - assert_equal("VOID", @m_open.return_type) - assert_equal("Folder", @m_namespace.return_type) - end - - def test_return_vtype - assert_equal(24, @m_open.return_vtype) - assert_equal(26, @m_namespace.return_vtype) - end - - def test_return_type_detail - assert_equal(['VOID'], @m_open.return_type_detail) - assert_equal(['PTR', 'USERDEFINED', 'Folder'], @m_namespace.return_type_detail) - end - - def test_invoke_kind - assert_equal('FUNC', @m_open.invoke_kind) - assert_equal('FUNC', @m_namespace.invoke_kind) - assert_equal('PROPERTYGET', @m_parent.invoke_kind) - end - - def test_invkind - assert_equal(1, @m_namespace.invkind) - assert_equal(2, @m_parent.invkind) - end - - def test_visible? - assert(@m_namespace.visible?) - assert(!@m_invoke.visible?) - end - - def test_helpstring - assert_equal("Get special folder from ShellSpecialFolderConstants", @m_namespace.helpstring) - end - - def test_helpfile - assert_equal("", @m_namespace.helpfile) - assert_match(/VBENLR.*\.CHM$/i, @m_file_name.helpfile) - end - - def test_helpcontext - assert_equal(0, @m_namespace.helpcontext) - assert_equal(2181996, @m_file_name.helpcontext) - end - - def test_dispid - assert_equal(1610743810, @m_namespace.dispid) - end - - def is_ruby64? - /mswin64|x64-mingw/ =~ RUBY_PLATFORM - end - - def test_offset_vtbl - exp = is_ruby64? ? 48 : 24 - assert_equal(exp, @m_invoke.offset_vtbl) - end - - def test_size_params - assert_equal(1, @m_open.size_params) - assert_equal(4, @m_browse_for_folder.size_params) - end - - def test_size_opt_params - assert_equal(0, @m_open.size_opt_params) - assert_equal(1, @m_browse_for_folder.size_opt_params) - end - - def test_params - params = @m_browse_for_folder.params - assert_instance_of(Array, params) - assert_equal(4, params.size) - assert_instance_of(WIN32OLE::Param, params[0]) - end - - def test_to_s - assert_equal(@m_namespace.name, @m_namespace.to_s) - end - - def test_inspect - assert_equal("#<WIN32OLE::Method:NameSpace>", @m_namespace.inspect) - end - - end -end diff --git a/test/win32ole/test_win32ole_method_event.rb b/test/win32ole/test_win32ole_method_event.rb deleted file mode 100644 index ab409a1f2d..0000000000 --- a/test/win32ole/test_win32ole_method_event.rb +++ /dev/null @@ -1,36 +0,0 @@ -begin - require 'win32ole' -rescue LoadError -end - -require 'test/unit' - -if defined?(WIN32OLE::Method) - require_relative 'available_ole' - class TestWIN32OLE_METHOD_EVENT < Test::Unit::TestCase - unless AvailableOLE.sysmon_available? - def test_dummy_for_skip_message - omit 'System Monitor Control is not available' - end - else - def setup - ole_type = WIN32OLE::Type.new('System Monitor Control', 'SystemMonitor') - @on_dbl_click = WIN32OLE::Method.new(ole_type, 'OnDblClick') - ole_type = WIN32OLE::Type.new('Microsoft Shell Controls And Automation', 'Shell') - @namespace = WIN32OLE::Method.new(ole_type, 'namespace') - end - - def test_event? - assert(@on_dbl_click.event?) - end - - def test_event_interface - assert('DISystemMonitorEvents', @on_dbl_click.event_interface) - end - - def test_event_interface_is_nil - assert_equal(nil, @namespace.event_interface) - end - end - end -end diff --git a/test/win32ole/test_win32ole_param.rb b/test/win32ole/test_win32ole_param.rb deleted file mode 100644 index 551da537fc..0000000000 --- a/test/win32ole/test_win32ole_param.rb +++ /dev/null @@ -1,98 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require "test/unit" - -if defined?(WIN32OLE::Param) - class TestWIN32OLE_PARAM < Test::Unit::TestCase - - def setup - ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "ShellLinkObject") - m_geticonlocation = WIN32OLE::Method.new(ole_type, "GetIconLocation") - @param_pbs = m_geticonlocation.params[0] - - ole_type = WIN32OLE::Type.new("Microsoft HTML Object Library", "FontNames") - m_count = WIN32OLE::Method.new(ole_type, "Count") - @param_p = m_count.params[0] - - ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "FileSystemObject") - m_copyfile = WIN32OLE::Method.new(ole_type, "CopyFile") - @param_source = m_copyfile.params[0] - @param_overwritefiles = m_copyfile.params[2] - - ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "Dictionary") - m_add = WIN32OLE::Method.new(ole_type, "Add") - @param_key = m_add.params[0] - end - - def test_s_new - assert_raise(ArgumentError) { - WIN32OLE::Param.new("hoge") - } - ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "FileSystemObject") - m_copyfile = WIN32OLE::Method.new(ole_type, "CopyFile") - assert_raise(IndexError) { - WIN32OLE::Param.new(m_copyfile, 4); - } - assert_raise(IndexError) { - WIN32OLE::Param.new(m_copyfile, 0); - } - param = WIN32OLE::Param.new(m_copyfile, 3) - assert_equal("OverWriteFiles", param.name) - assert_equal(WIN32OLE::Param, param.class) - assert_equal(true, param.default) - assert_equal("#<WIN32OLE::Param:OverWriteFiles=true>", param.inspect) - end - - def test_name - assert_equal('Source', @param_source.name) - assert_equal('Key', @param_key.name) - end - - def test_ole_type - assert_equal('BSTR', @param_source.ole_type) - assert_equal('VARIANT', @param_key.ole_type) - end - - def test_ole_type_detail - assert_equal(['BSTR'], @param_source.ole_type_detail) - assert_equal(['PTR', 'VARIANT'], @param_key.ole_type_detail) - end - - def test_input? - assert_equal(true, @param_source.input?) - assert_equal(false, @param_pbs.input?) - end - - def test_output? - assert_equal(false, @param_source.output?) - assert_equal(true, @param_pbs.output?) - end - - def test_optional? - assert_equal(false, @param_source.optional?) - assert_equal(true, @param_overwritefiles.optional?) - end - - def test_retval? - assert_equal(false, @param_source.retval?) - assert_equal(true, @param_p.retval?) - end - - def test_default - assert_equal(nil, @param_source.default) - assert_equal(true, @param_overwritefiles.default) - end - - def test_to_s - assert_equal(@param_source.name, @param_source.to_s) - end - - def test_inspect - assert_equal("#<WIN32OLE::Param:Source>", @param_source.inspect) - assert_equal("#<WIN32OLE::Param:OverWriteFiles=true>", @param_overwritefiles.inspect) - end - end -end diff --git a/test/win32ole/test_win32ole_param_event.rb b/test/win32ole/test_win32ole_param_event.rb deleted file mode 100644 index f5a16ead76..0000000000 --- a/test/win32ole/test_win32ole_param_event.rb +++ /dev/null @@ -1,30 +0,0 @@ -begin - require 'win32ole' -rescue LoadError -end - -require 'test/unit' - -if defined?(WIN32OLE::Param) - require_relative 'available_ole' - - class TestWIN32OLE_PARAM_EVENT < Test::Unit::TestCase - if AvailableOLE.msxml_available? || AvailableOLE.ado_available? - def setup - @param = AvailableOLE.event_param - end - - def test_input? - assert_equal(true, @param.input?) - end - - def test_output? - assert_equal(true, @param.output?) - end - else - def test_dummy_for_skip_message - omit 'ActiveX Data Object Library and MS XML not found' - end - end - end -end diff --git a/test/win32ole/test_win32ole_record.rb b/test/win32ole/test_win32ole_record.rb deleted file mode 100644 index 2fae16788d..0000000000 --- a/test/win32ole/test_win32ole_record.rb +++ /dev/null @@ -1,212 +0,0 @@ -# coding: us-ascii -# frozen_string_literal: false - -begin - require 'win32ole' -rescue LoadError -end -require 'test/unit' - -PROGID_RBCOMTEST='RbComTest.ComSrvTest' - -=begin -RbComTest.ComSrvTest is following VB.NET COM server(RbComTest solution). -(You must check COM interoperability.) - -Imports System.Runtime.InteropServices -Public Class ComSrvTest - <StructLayout(LayoutKind.Sequential)> _ - Public Structure Book - <MarshalAs(UnmanagedType.BStr)> _ - Public title As String - Public cost As Integer - End Structure - - Public Function getBook() As Book - Dim book As New Book - book.title = "The Ruby Book" - book.cost = 20 - Return book - End Function - - Public Function getBooks() As Book() - Dim book() As Book = {New Book, New Book} - book(0).title = "The CRuby Book" - book(0).cost = 30 - book(1).title = "The JRuby Book" - book(1).cost = 40 - Return book - End Function - - Public Sub getBookByRefObject(ByRef obj As Object) - Dim book As New Book - book.title = "The Ruby Reference Book" - book.cost = 50 - obj = book - End Sub - - Public Function getVer2BookByValBook(<MarshalAs(UnmanagedType.Struct)> ByVal book As Book) As Book - Dim ret As New Book - ret.title = book.title + " ver2" - ret.cost = book.cost * 1.1 - Return ret - End Function - - Public Sub getBookByRefBook(<MarshalAs(UnmanagedType.LPStruct)> ByRef book As Book) - book.title = "The Ruby Reference Book2" - book.cost = 44 - End Sub - - Public Sub getVer3BookByRefBook(<MarshalAs(UnmanagedType.LPStruct)> ByRef book As Book) - book.title += " ver3" - book.cost *= 1.2 - End Sub -End Class -=end - - -if defined?(WIN32OLE::Record) - class TestWIN32OLE_RECORD < Test::Unit::TestCase - end - - def rbcomtest_exist? - WIN32OLE.new(PROGID_RBCOMTEST) - true - rescue WIN32OLE::RuntimeError - false - end - - class TestWIN32OLE_RECORD_BY_RBCOMTEST < Test::Unit::TestCase - unless rbcomtest_exist? - def test_dummy_for_skip_message - omit "#{PROGID_RBCOMTEST} for WIN32OLE::Record test is not installed" - end - else - def setup - @obj = WIN32OLE.new(PROGID_RBCOMTEST) - end - - def test_s_new_from_win32ole - rec = WIN32OLE::Record.new('Book', @obj) - assert(rec) - assert_instance_of(WIN32OLE::Record, rec) - end - - def test_s_new_from_win32ole_typelib - tlib = @obj.ole_typelib - rec = WIN32OLE::Record.new('Book', tlib) - assert(rec) - assert_instance_of(WIN32OLE::Record, rec) - end - - def test_s_new_raise - assert_raise(WIN32OLE::RuntimeError) { - WIN32OLE::Record.new('NonExistRecordName', @obj) - } - assert_raise(ArgumentError) { - WIN32OLE::Record.new - } - assert_raise(ArgumentError) { - WIN32OLE::Record.new('NonExistRecordName') - } - end - - def test_to_h - rec = WIN32OLE::Record.new('Book', @obj) - assert_equal({'title'=>nil, 'cost'=>nil}, rec.to_h) - end - - def test_typename - rec = WIN32OLE::Record.new('Book', @obj) - assert_equal('Book', rec.typename) - end - - def test_method_missing_getter - rec = WIN32OLE::Record.new('Book', @obj) - assert_equal(nil, rec.title) - assert_raise(KeyError) { - rec.non_exist_name - } - end - - def test_method_missing_setter - rec = WIN32OLE::Record.new('Book', @obj) - rec.title = "Ruby Book" - assert_equal("Ruby Book", rec.title) - end - - def test_get_record_from_comserver - rec = @obj.getBook - assert_instance_of(WIN32OLE::Record, rec) - assert_equal("The Ruby Book", rec.title) - assert_equal(20, rec.cost) - end - - def test_get_record_array_from_comserver - rec = @obj.getBooks - assert_instance_of(Array, rec) - assert_equal(2, rec.size) - assert_instance_of(WIN32OLE::Record, rec[0]) - assert_equal("The CRuby Book", rec[0].title) - assert_equal(30, rec[0].cost) - assert_instance_of(WIN32OLE::Record, rec[1]) - assert_equal("The JRuby Book", rec[1].title) - assert_equal(40, rec[1].cost) - end - - def test_pass_record_parameter - rec = WIN32OLE::Record.new('Book', @obj) - rec.title = "Ruby Book" - rec.cost = 60 - book = @obj.getVer2BookByValBook(rec) - assert_equal("Ruby Book ver2", book.title) - assert_equal(66, book.cost) - end - - def test_pass_variant_parameter_byref - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_VARIANT|WIN32OLE::VARIANT::VT_BYREF) - @obj.getBookByRefBook(obj) - assert_instance_of(WIN32OLE::Record, obj.value) - book = obj.value - assert_equal("The Ruby Reference Book2", book.title) - assert_equal(44, book.cost) - end - - def test_pass_record_parameter_byref - book = WIN32OLE::Record.new('Book', @obj) - @obj.getBookByRefBook(book) - assert_equal("The Ruby Reference Book2", book.title) - assert_equal(44, book.cost) - end - - def test_pass_and_get_record_parameter_byref - book = WIN32OLE::Record.new('Book', @obj) - book.title = "Ruby Book" - book.cost = 60 - @obj.getVer3BookByRefBook(book) - assert_equal("Ruby Book ver3", book.title) - assert_equal(72, book.cost) - end - - def test_ole_instance_variable_get - obj = WIN32OLE::Record.new('Book', @obj) - assert_equal(nil, obj.ole_instance_variable_get(:title)) - assert_equal(nil, obj.ole_instance_variable_get('title')) - end - - def test_ole_instance_variable_set - book = WIN32OLE::Record.new('Book', @obj) - book.ole_instance_variable_set(:title, "Ruby Book") - assert_equal("Ruby Book", book.title) - book.ole_instance_variable_set('title', "Ruby Book2") - assert_equal("Ruby Book2", book.title) - end - - def test_inspect - book = WIN32OLE::Record.new('Book', @obj) - assert_equal(%q[#<WIN32OLE::Record(Book) {"title"=>nil, "cost"=>nil}>], book.inspect) - end - end - end - -end diff --git a/test/win32ole/test_win32ole_type.rb b/test/win32ole/test_win32ole_type.rb deleted file mode 100644 index df1ba6556c..0000000000 --- a/test/win32ole/test_win32ole_type.rb +++ /dev/null @@ -1,199 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require "test/unit" - -if defined?(WIN32OLE::Type) - class TestWIN32OLE_TYPE < Test::Unit::TestCase - def test_s_progids - progids = WIN32OLE::Type.progids - assert_instance_of(Array, progids) - assert(progids.size > 0) - assert_instance_of(String, progids[0]) - assert(progids.include?("Shell.Application.1")) - end - - def test_initialize - assert_raise(ArgumentError) { - WIN32OLE::Type.new - } - assert_raise(ArgumentError) { - WIN32OLE::Type.new("foo") - } - assert_raise(TypeError) { - WIN32OLE::Type.new(1, 2) - } - assert_raise(TypeError) { - WIN32OLE::Type.new("Microsoft Shell Controls And Automation", 1) - } - assert_raise(WIN32OLE::RuntimeError) { - WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "foo") - } - assert_raise(WIN32OLE::RuntimeError) { - WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Application") - } - ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Shell") - assert_instance_of(WIN32OLE::Type, ole_type) - assert_equal("Shell", ole_type.name) - assert_equal("Class", ole_type.ole_type) - assert_equal("{13709620-C279-11CE-A49E-444553540000}", ole_type.guid) - assert_equal("Shell.Application.1", ole_type.progid) - assert_equal(true, ole_type.visible?) - assert_equal("Shell", ole_type.to_s) - assert_equal(0, ole_type.major_version) - assert_equal(0, ole_type.minor_version) - assert_equal(5, ole_type.typekind) - assert_equal("Shell Object Type Information", ole_type.helpstring) - assert_equal(nil, ole_type.src_type) - assert_equal("", ole_type.helpfile) - assert_equal(0, ole_type.helpcontext) - assert_equal([], ole_type.variables) - assert(ole_type.ole_methods.select{|m|/NameSpace/i =~ m.name}.size > 0) - - ole_type2 = WIN32OLE::Type.new("{13709620-C279-11CE-A49E-444553540000}", "Shell") - assert_instance_of(WIN32OLE::Type, ole_type) - assert_equal(ole_type.name, ole_type2.name) - assert_equal(ole_type.ole_type, ole_type2.ole_type) - assert_equal(ole_type.guid, ole_type2.guid) - assert_equal(ole_type.progid, ole_type2.progid) - assert_equal(ole_type.visible?, ole_type2.visible?) - assert_equal(ole_type.to_s, ole_type2.to_s) - assert_equal(ole_type.major_version, ole_type2.major_version) - assert_equal(ole_type.minor_version, ole_type2.minor_version) - assert_equal(ole_type.typekind, ole_type2.typekind) - assert_equal(ole_type.helpstring, ole_type2.helpstring) - assert_equal(ole_type.src_type, ole_type2.src_type) - assert_equal(ole_type.helpfile, ole_type2.helpfile) - assert_equal(ole_type.helpcontext, ole_type2.helpcontext) - assert_equal(ole_type.variables.size, ole_type2.variables.size) - assert_equal(ole_type.ole_methods[0].name, ole_type2.ole_methods[0].name) - assert_equal(ole_type.ole_typelib.name, ole_type2.ole_typelib.name) - assert_equal(ole_type.implemented_ole_types.size, ole_type2.implemented_ole_types.size) - assert_equal(ole_type.inspect, ole_type2.inspect) - end - - def setup - @ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "Shell") - end - - def test_name - assert_equal("Shell", @ole_type.name) - end - - def test_ole_type - assert_equal("Class", @ole_type.ole_type) - end - - def test_guid - assert_equal("{13709620-C279-11CE-A49E-444553540000}", @ole_type.guid) - end - - def test_progid - assert_equal("Shell.Application.1", @ole_type.progid) - end - - def test_visible? - assert(@ole_type.visible?) - ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "IShellDispatch") - assert(!ole_type.visible?) - end - - def test_to_s - assert_equal(@ole_type.to_s, @ole_type.name) - end - - def test_major_version - assert_equal(0, @ole_type.major_version) - # ole_type = WIN32OLE::Type.new("Microsoft Word 11.0 Object Library", "Documents") - # assert_equal(8, ole_type.major_version) - end - - def test_minor_version - assert_equal(0, @ole_type.minor_version) - # ole_type = WIN32OLE::Type.new("Microsoft Word 11.0 Object Library", "Documents") - # assert_equal(3, ole_type.minor_version) - end - - def test_typekind - assert_equal(5, @ole_type.typekind) - end - - def test_helpstring - assert_equal("Shell Object Type Information", @ole_type.helpstring) - end - - def test_src_type - ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "DriveTypeConst") - assert_match(/__MIDL___MIDL_itf_scrrun_/, ole_type.src_type) - assert_equal(nil, @ole_type.src_type) - end - - def test_helpfile - assert_equal("", @ole_type.helpfile) - ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "Folders") - assert_match(/VBENLR98\.CHM$/i, ole_type.helpfile) - end - - def test_helpcontext - assert_equal(0, @ole_type.helpcontext) - ole_type = WIN32OLE::Type.new("Microsoft Scripting Runtime", "Folders") - assert_equal(2181929, ole_type.helpcontext) - end - - def test_variables - variables = @ole_type.variables - assert_instance_of(Array, variables) - assert(variables.size == 0) - - ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "ShellSpecialFolderConstants") - variables = ole_type.variables - assert_instance_of(Array, variables) - assert(variables.size > 0) - - assert_instance_of(WIN32OLE::Variable, variables[0]) - end - - def test_ole_methods - methods = @ole_type.ole_methods - assert_instance_of(Array, methods) - assert(methods.size > 0) - assert_instance_of(WIN32OLE::Method, methods[0]); - assert(methods.collect{|m| m.name}.include?("Application")) - end - - def test_ole_typelib - tlib = @ole_type.ole_typelib - assert_instance_of(WIN32OLE::TypeLib, tlib) - assert_equal("Microsoft Shell Controls And Automation", tlib.name) - end - - def test_implemented_ole_types - ole_types = @ole_type.implemented_ole_types - assert_instance_of(Array, ole_types) - assert_equal(1, ole_types.size) - assert_match(/^IShellDispatch\d{0,1}$/, ole_types[0].name) - end - - def test_inspect - assert_equal("#<WIN32OLE::Type:Shell>", @ole_type.inspect) - end - - # WIN32OLE::Type.typelibs will be obsoleted. - def test_s_typelibs - tlibs = WIN32OLE::Type.typelibs.sort - tlibs2 = WIN32OLE::TypeLib.typelibs.collect{|t|t.name}.sort - assert_equal(tlibs2, tlibs) - end - - # WIN32OLE::Type.ole_classes will be obsoleted. - def test_s_ole_classes - ots1 = WIN32OLE::Type.ole_classes("Microsoft Shell Controls And Automation") - ots2 = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation").ole_types - otns1 = ots1.collect{|t| t.name}.sort - otns2 = ots2.collect{|t| t.name}.sort - assert_equal(otns2, otns1) - end - end -end diff --git a/test/win32ole/test_win32ole_type_event.rb b/test/win32ole/test_win32ole_type_event.rb deleted file mode 100644 index 5d1c9fc44c..0000000000 --- a/test/win32ole/test_win32ole_type_event.rb +++ /dev/null @@ -1,44 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end - -require 'test/unit' - -if defined?(WIN32OLE::Type) - require_relative 'available_ole' - - class TestWIN32OLE_TYPE_EVENT < Test::Unit::TestCase - unless AvailableOLE.sysmon_available? - def test_dummy_for_skip_message - omit 'System Monitor Control is not available' - end - else - - def setup - @ole_type = WIN32OLE::Type.new('System Monitor Control', 'SystemMonitor') - end - - def test_implemented_ole_types - ole_types = @ole_type.implemented_ole_types.map(&:name).sort - assert_equal(['DISystemMonitor', 'DISystemMonitorEvents', 'ISystemMonitor'], ole_types) - end - - def test_default_ole_types - ole_types = @ole_type.default_ole_types.map(&:name).sort - assert_equal(['DISystemMonitor', 'DISystemMonitorEvents'], ole_types) - end - - def test_source_ole_types - ole_types = @ole_type.source_ole_types.map(&:name) - assert_equal(['DISystemMonitorEvents'], ole_types) - end - - def test_default_event_sources - event_sources = @ole_type.default_event_sources.map(&:name) - assert_equal(['DISystemMonitorEvents'], event_sources) - end - end - end -end diff --git a/test/win32ole/test_win32ole_typelib.rb b/test/win32ole/test_win32ole_typelib.rb deleted file mode 100644 index f743ad68f9..0000000000 --- a/test/win32ole/test_win32ole_typelib.rb +++ /dev/null @@ -1,117 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require "test/unit" - -if defined?(WIN32OLE::TypeLib) - class TestWIN32OLE_TYPELIB < Test::Unit::TestCase - def test_s_typelibs - tlibs = WIN32OLE::TypeLib.typelibs - assert_instance_of(Array, tlibs) - assert(tlibs.size > 0) - tlib = tlibs.find {|t| t.name == "Microsoft Shell Controls And Automation"} - assert(tlib) - end - - def test_initialize - assert_raise(ArgumentError) { - WIN32OLE::TypeLib.new(1,2,3,4) - } - - assert_raise(TypeError) { - WIN32OLE::TypeLib.new(100) - } - - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_instance_of(WIN32OLE::TypeLib, tlib) - - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation", 1.0) - assert_instance_of(WIN32OLE::TypeLib, tlib) - - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation", 1, 0) - assert_instance_of(WIN32OLE::TypeLib, tlib) - guid = tlib.guid - - tlib_by_guid = WIN32OLE::TypeLib.new(guid, 1, 0) - assert_instance_of(WIN32OLE::TypeLib, tlib_by_guid) - assert_equal("Microsoft Shell Controls And Automation" , tlib_by_guid.name) - - path = tlib.path - tlib_by_path = WIN32OLE::TypeLib.new(path) - assert_equal("Microsoft Shell Controls And Automation" , tlib_by_path.name) - - assert_raise(WIN32OLE::RuntimeError) { - WIN32OLE::TypeLib.new("Non Exist Type Library") - } - end - - # #Bug:3907 [ruby-dev:42338] - def test_initialize_with_REG_EXPAND_SZ - tlib = WIN32OLE::TypeLib.new("Disk Management Snap-In Object Library") - assert_instance_of(WIN32OLE::TypeLib, tlib) - end - - def test_guid - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_equal("{50A7E9B0-70EF-11D1-B75A-00A0C90564FE}", tlib.guid) - end - - def test_name - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_equal("Microsoft Shell Controls And Automation", tlib.name) - tlib = WIN32OLE::TypeLib.new("{50A7E9B0-70EF-11D1-B75A-00A0C90564FE}") - assert_equal("Microsoft Shell Controls And Automation", tlib.name) - end - - def test_version - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_equal("1.0", tlib.version) - end - - def test_major_version - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_equal(1, tlib.major_version) - end - - def test_minor_version - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_equal(0, tlib.minor_version) - end - - def test_path - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_match(/shell32\.dll$/i, tlib.path) - end - - def test_visible? - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert(tlib.visible?) - end - - def test_library_name - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_equal("Shell32", tlib.library_name) - end - - def test_to_s - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_equal("Microsoft Shell Controls And Automation", tlib.to_s) - end - - def test_ole_types - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - ole_types = tlib.ole_types - assert_instance_of(Array, ole_types) - assert(ole_types.size > 0) - assert_instance_of(WIN32OLE::Type, ole_types[0]) - end - - def test_inspect - tlib = WIN32OLE::TypeLib.new("Microsoft Shell Controls And Automation") - assert_equal("#<WIN32OLE::TypeLib:Microsoft Shell Controls And Automation>", tlib.inspect) - end - - end -end diff --git a/test/win32ole/test_win32ole_variable.rb b/test/win32ole/test_win32ole_variable.rb deleted file mode 100644 index 74a6cbd890..0000000000 --- a/test/win32ole/test_win32ole_variable.rb +++ /dev/null @@ -1,66 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require "test/unit" - -if defined?(WIN32OLE::Variable) - class TestWIN32OLE_VARIABLE < Test::Unit::TestCase - - def setup - ole_type = WIN32OLE::Type.new("Microsoft Shell Controls And Automation", "ShellSpecialFolderConstants") - @var1 = ole_type.variables.find {|v| v.name == 'ssfDESKTOP'} - - variables = WIN32OLE::Type.new("Microsoft Windows Installer Object Library", "Installer").variables - @var2 = variables.find {|v| v.name == 'UILevel'} - end - - def test_initialize - assert_raise(TypeError) {WIN32OLE::Variable.new} - end - - def test_name - assert_equal('ssfDESKTOP', @var1.name) - end - - def test_ole_type - assert_equal('INT', @var1.ole_type) - assert_equal('MsiUILevel', @var2.ole_type) - end - - def test_ole_type_detail - assert_equal(['INT'], @var1.ole_type_detail) - assert_equal(['USERDEFINED', 'MsiUILevel'], @var2.ole_type_detail) - end - - def test_ole_type_value - assert_equal(0, @var1.value) - assert_equal(nil, @var2.value) - end - - def test_ole_type_visible? - assert(@var1.visible?) - end - - def test_ole_type_variable_kind - assert_equal("CONSTANT", @var1.variable_kind) - assert_equal("DISPATCH", @var2.variable_kind) - end - - def test_ole_type_varkind - assert_equal(2, @var1.varkind) - assert_equal(3, @var2.varkind) - end - - def test_to_s - assert_equal(@var1.name, @var1.to_s) - end - - def test_inspect - assert_equal("#<WIN32OLE::Variable:ssfDESKTOP=0>", @var1.inspect) - assert_equal("#<WIN32OLE::Variable:UILevel=nil>", @var2.inspect) - end - - end -end diff --git a/test/win32ole/test_win32ole_variant.rb b/test/win32ole/test_win32ole_variant.rb deleted file mode 100644 index 1837a1e1d6..0000000000 --- a/test/win32ole/test_win32ole_variant.rb +++ /dev/null @@ -1,722 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require "test/unit" - -if defined?(WIN32OLE::Variant) - - class TestWIN32OLE_VARIANT < Test::Unit::TestCase - def setup - @orglocale = WIN32OLE.locale - WIN32OLE.locale = 0x0409 # set locale US-Eng - end - - def teardown - WIN32OLE.locale = @orglocale - end - - def test_s_new - obj = WIN32OLE::Variant.new('foo') - assert_instance_of(WIN32OLE::Variant, obj) - end - - def test_s_new_exc - assert_raise(TypeError) { - WIN32OLE::Variant.new(/foo/) - } - end - - def test_s_new_ary - obj = WIN32OLE::Variant.new([1]) - assert_instance_of(WIN32OLE::Variant, obj) - assert_raise(TypeError) { - WIN32OLE::Variant.new([/foo/]) - } - end - - def test_s_new_no_argument - pat = /wrong number of arguments \(.*\b0\b.* 1\.\.3\)/ - assert_raise_with_message(ArgumentError, pat) do - WIN32OLE::Variant.new - end - end - - def test_s_new_one_argument - ex = nil - begin - WIN32OLE::Variant.new('foo') - rescue - ex = $! - end - assert_equal(nil, ex); - end - - def test_s_new_with_nil - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_I2) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I2, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_I4) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_R4) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_R4, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_R8) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_R8, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_CY) - assert_equal("0", obj.value) - assert_equal(WIN32OLE::VARIANT::VT_CY, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(1899,12,30), obj.value) - assert_equal(WIN32OLE::VARIANT::VT_DATE, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_BSTR) - assert_equal("", obj.value) - assert_equal(WIN32OLE::VARIANT::VT_BSTR, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_DISPATCH) - assert_nil(obj.value) - assert_equal(WIN32OLE::VARIANT::VT_DISPATCH, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_BOOL) - assert_equal(false, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_BOOL, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_VARIANT) - assert_nil(obj.value) - assert_equal(WIN32OLE::VARIANT::VT_VARIANT, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_I1) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I1, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UI1) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI1, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UI2) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI2, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UI4) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI4, obj.vartype) - - - if defined?(WIN32OLE::VARIANT::VT_I8) - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_I8) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I8, obj.vartype) - end - - if defined?(WIN32OLE::VARIANT::VT_UI8) - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UI8) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI8, obj.vartype) - end - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_INT) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_INT, obj.vartype) - - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_UINT) - assert_equal(0, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UINT, obj.vartype) - end - - def test_s_new_with_non_nil - obj = WIN32OLE::Variant.new(2, WIN32OLE::VARIANT::VT_I2) - assert_equal(2, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I2, obj.vartype) - - obj = WIN32OLE::Variant.new(3, WIN32OLE::VARIANT::VT_I4) - assert_equal(3, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype) - - obj = WIN32OLE::Variant.new(4.5, WIN32OLE::VARIANT::VT_R4) - assert_equal(4.5, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_R4, obj.vartype) - - obj = WIN32OLE::Variant.new(5.5, WIN32OLE::VARIANT::VT_R8) - assert_equal(5.5, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_R8, obj.vartype) - - obj = WIN32OLE::Variant.new(600, WIN32OLE::VARIANT::VT_CY) - assert_equal("600", obj.value) - assert_equal(WIN32OLE::VARIANT::VT_CY, obj.vartype) - - obj = WIN32OLE::Variant.new("2001-06-15 12:17:34", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(2001,06,15,12,17,34), obj.value) - assert_equal(WIN32OLE::VARIANT::VT_DATE, obj.vartype) - - obj = WIN32OLE::Variant.new("foo", WIN32OLE::VARIANT::VT_BSTR) - assert_equal("foo", obj.value) - assert_equal(WIN32OLE::VARIANT::VT_BSTR, obj.vartype) - - obj = WIN32OLE::Variant.new(true, WIN32OLE::VARIANT::VT_BOOL) - assert_equal(true, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_BOOL, obj.vartype) - - obj = WIN32OLE::Variant.new(2, WIN32OLE::VARIANT::VT_I1) - assert_equal(2, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I1, obj.vartype) - - obj = WIN32OLE::Variant.new(3, WIN32OLE::VARIANT::VT_UI1) - assert_equal(3, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI1, obj.vartype) - - obj = WIN32OLE::Variant.new(4, WIN32OLE::VARIANT::VT_UI2) - assert_equal(4, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI2, obj.vartype) - - obj = WIN32OLE::Variant.new(5, WIN32OLE::VARIANT::VT_UI4) - assert_equal(5, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI4, obj.vartype) - - if defined?(WIN32OLE::VARIANT::VT_I8) - obj = WIN32OLE::Variant.new(-123456789012345, WIN32OLE::VARIANT::VT_I8) - assert_equal(-123456789012345, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I8, obj.vartype) - end - - if defined?(WIN32OLE::VARIANT::VT_UI8) - obj = WIN32OLE::Variant.new(123456789012345, WIN32OLE::VARIANT::VT_UI8) - assert_equal(123456789012345, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI8, obj.vartype) - end - - obj = WIN32OLE::Variant.new(4, WIN32OLE::VARIANT::VT_INT) - assert_equal(4, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_INT, obj.vartype) - - obj = WIN32OLE::Variant.new(5, WIN32OLE::VARIANT::VT_UINT) - assert_equal(5, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UINT, obj.vartype) - end - - def test_s_new_with_non_nil_byref - obj = WIN32OLE::Variant.new(2, WIN32OLE::VARIANT::VT_I2|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(2, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I2|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(3, WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(3, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(4.5, WIN32OLE::VARIANT::VT_R4|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(4.5, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_R4|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(5.5, WIN32OLE::VARIANT::VT_R8|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(5.5, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_R8|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(600, WIN32OLE::VARIANT::VT_CY|WIN32OLE::VARIANT::VT_BYREF) - assert_equal("600", obj.value) - assert_equal(WIN32OLE::VARIANT::VT_CY|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new("2001-06-15 12:17:34", WIN32OLE::VARIANT::VT_DATE|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(Time.new(2001,06,15,12,17,34), obj.value) - assert_equal(WIN32OLE::VARIANT::VT_DATE|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new("foo", WIN32OLE::VARIANT::VT_BSTR|WIN32OLE::VARIANT::VT_BYREF) - assert_equal("foo", obj.value) - assert_equal(WIN32OLE::VARIANT::VT_BSTR|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(true, WIN32OLE::VARIANT::VT_BOOL|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(true, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_BOOL|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(2, WIN32OLE::VARIANT::VT_I1|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(2, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I1|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(3, WIN32OLE::VARIANT::VT_UI1|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(3, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI1|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(4, WIN32OLE::VARIANT::VT_UI2|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(4, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI2|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(5, WIN32OLE::VARIANT::VT_UI4|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(5, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI4|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(4, WIN32OLE::VARIANT::VT_INT|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(4, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_INT|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - - obj = WIN32OLE::Variant.new(5, WIN32OLE::VARIANT::VT_UINT|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(5, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UINT|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - end - - def test_s_new_with_i8_byref - obj = WIN32OLE::Variant.new(-123456789012345, WIN32OLE::VARIANT::VT_I8|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(-123456789012345, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I8|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - end - - def test_s_new_with_ui8_byref - obj = WIN32OLE::Variant.new(123456789012345, WIN32OLE::VARIANT::VT_UI8|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(123456789012345, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_UI8|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - end - - def test_value - obj = WIN32OLE::Variant.new('foo') - assert_equal('foo', obj.value) - end - - def test_s_new_2_argument - obj = WIN32OLE::Variant.new('foo', WIN32OLE::VARIANT::VT_BSTR|WIN32OLE::VARIANT::VT_BYREF) - assert_equal('foo', obj.value); - end - - def test_s_new_2_argument2 - obj = WIN32OLE::Variant.new('foo', WIN32OLE::VARIANT::VT_BSTR) - assert_equal('foo', obj.value); - end - - def test_s_new_dispatch_array - vt = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_DISPATCH - obj = WIN32OLE::Variant.new(nil, vt) - assert_equal(vt, obj.vartype) - assert_nil(obj.value) - - vt = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_DISPATCH|WIN32OLE::VARIANT::VT_BYREF - obj = WIN32OLE::Variant.new(nil, vt) - assert_equal(vt, obj.vartype) - assert_nil(obj.value) - end - - def test_s_new_array - # should not occur stack over flow - ar = (1..500000).to_a.map{|i| [i]} - ar2 = WIN32OLE::Variant.new(ar) - assert_equal(ar, ar2.value) - end - - def test_s_new_vt_record_exc - # VT_RECORD (= 36) should not be allowed in WIN32OLE::Variant#new - assert_raise(ArgumentError) { - WIN32OLE::Variant.new(nil, 36) - } - end - - def test_s_array - obj = WIN32OLE::Variant.array([2,3], WIN32OLE::VARIANT::VT_I4) - assert_instance_of(WIN32OLE::Variant, obj) - assert_equal(WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_ARRAY, obj.vartype) - assert_equal([[0, 0, 0],[0, 0, 0]], obj.value) - - obj = WIN32OLE::Variant.array([2,3], WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF|WIN32OLE::VARIANT::VT_ARRAY, obj.vartype) - assert_equal([[0, 0, 0],[0, 0, 0]], obj.value) - - obj = WIN32OLE::Variant.array([2,3], WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_ARRAY) - assert_instance_of(WIN32OLE::Variant, obj) - assert_equal(WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_ARRAY, obj.vartype) - assert_equal([[0, 0, 0],[0, 0, 0]], obj.value) - - assert_equal(0, obj[0,0]) - obj[0,0] = 10 - assert_equal([[10, 0, 0],[0, 0, 0]], obj.value) - obj[0,1] = "13.2" - assert_equal([[10, 13, 0],[0, 0, 0]], obj.value) - - obj = WIN32OLE::Variant.array([3, 2], WIN32OLE::VARIANT::VT_VARIANT) - obj[0,0] = 10 - obj[0,1] = "string" - obj[1,0] = 12.735 - assert_equal([[10, "string"],[12.735, nil],[nil,nil]], obj.value) - - obj = WIN32OLE::Variant.array([2,3], WIN32OLE::VARIANT::VT_DISPATCH) - assert_equal([[nil, nil, nil],[nil,nil,nil]], obj.value) - - end - - def test_s_array_exc - assert_raise(TypeError) { - WIN32OLE::Variant.array(2, WIN32OLE::VARIANT::VT_I4) - } - end - - def test_conversion_num2str - obj = WIN32OLE::Variant.new(124, WIN32OLE::VARIANT::VT_BSTR) - assert_equal("124", obj.value); - end - - def test_conversion_float2int - obj = WIN32OLE::Variant.new(12.345, WIN32OLE::VARIANT::VT_I4) - assert_equal(12, obj.value) - obj = WIN32OLE::Variant.new(12.345, WIN32OLE::VARIANT::VT_I4|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(12, obj.value) - end - - def test_conversion_str2num - obj = WIN32OLE::Variant.new("12.345", WIN32OLE::VARIANT::VT_R8) - assert_equal(12.345, obj.value) - end - - def test_conversion_ole_variant2ole_variant - obj = WIN32OLE::Variant.new("12.345", WIN32OLE::VARIANT::VT_R4) - obj = WIN32OLE::Variant.new(obj, WIN32OLE::VARIANT::VT_I4) - assert_equal(12, obj.value) - end - - def test_conversion_str2date - obj = WIN32OLE::Variant.new("2004-12-24 12:24:45", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(2004,12,24,12,24,45), obj.value) - end - - def test_conversion_time2date - dt = Time.mktime(2004, 12, 24, 12, 24, 45) - obj = WIN32OLE::Variant.new(dt, WIN32OLE::VARIANT::VT_DATE) - assert_equal(dt, obj.value) - end - - def test_conversion_dbl2date_with_msec - # Date is "2014/8/27 12:34:56.789" - obj = WIN32OLE::Variant.new(41878.524268391200167, WIN32OLE::VARIANT::VT_DATE) - t = obj.value - assert_equal("2014-08-27 12:34:56", t.strftime('%Y-%m-%d %H:%M:%S')) - assert_in_delta(0.789, t.nsec / 1000000000.0, 0.001) - end - - def test_conversion_time2date_with_msec - t0 = Time.new(2014, 8, 27, 12, 34, 56) - t0 += 0.789 - t1 = WIN32OLE::Variant.new(t0).value - - # The t0.nsec is 789000000 and t1.nsec is 789000465 - # because of error range by conversion Time between VT_DATE Variant. - # So check t1 and t0 are in error by less than one millisecond. - msg = "Expected:#{t0.strftime('%Y-%m-%dT%H:%M:%S.%N')} but was:#{t1.strftime('%Y-%m-%dT%H:%M:%S.%N')}" - assert_in_delta(t0, t1, 0.001, msg) - - t0 = Time.new(2014, 8, 27, 12, 34, 56) - t0 += 0.999999999 - t1 = WIN32OLE::Variant.new(t0).value - msg = "Expected:#{t0.strftime('%Y-%m-%dT%H:%M:%S.%N')} but was:#{t1.strftime('%Y-%m-%dT%H:%M:%S.%N')}" - - # The t0 is "2014/08/27 12:34.56.999999999" and - # the t1 is "2014/08/27 12:34:57.000000628" - assert_in_delta(t0, t1, 0.001, msg) - - t0 = Time.now - t1 = WIN32OLE::Variant.new(t0).value - msg = "Expected:#{t0.strftime('%Y-%m-%dT%H:%M:%S.%N')} but was:#{t1.strftime('%Y-%m-%dT%H:%M:%S.%N')}" - assert_in_delta(t0, t1, 0.001, msg) - end - - # this test failed because of VariantTimeToSystemTime - # and SystemTimeToVariantTime API ignores wMilliseconds - # member of SYSTEMTIME struct. - # - # def test_conversion_time_nsec2date - # dt = Time.new(2004, 12,24, 12, 24, 45) - # dt += 0.1 - # obj = WIN32OLE::Variant.new(dt, WIN32OLE::VARIANT::VT_DATE) - # assert_equal(dt, obj.value) - # end - - def test_conversion_str2cy - begin - WIN32OLE.locale = 0x0411 # set locale Japanese - rescue WIN32OLE::RuntimeError - omit("Japanese locale is not installed") - end - if WIN32OLE.locale == 0x0411 - obj = WIN32OLE::Variant.new("\\10,000", WIN32OLE::VARIANT::VT_CY) - assert_equal("10000", obj.value) - end - end - - def test_create_vt_array - obj = WIN32OLE::Variant.new([1.2, 2.3], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_R8) - assert_equal([1.2, 2.3], obj.value) - assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_R8, obj.vartype) - - obj = WIN32OLE::Variant.new([1.2, 2.3], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_R8|WIN32OLE::VARIANT::VT_BYREF) - assert_equal([1.2, 2.3], obj.value) - assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_R8|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - end - - def test_create_vt_array2 - obj = WIN32OLE::Variant.new([1.2, "a"], WIN32OLE::VARIANT::VT_ARRAY) - assert_equal([1.2, "a"], obj.value) - assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_VARIANT, obj.vartype) - - obj = WIN32OLE::Variant.new([1.2, "a"]) - assert_equal([1.2, "a"], obj.value) - assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_VARIANT, obj.vartype) - end - - - def test_create_vt_nested_array - obj = WIN32OLE::Variant.new([[1.2, "a", "b"], [3.4, "C", "D"]], WIN32OLE::VARIANT::VT_ARRAY) - assert_equal([[1.2, "a", "b"], [3.4, "C", "D"]], obj.value) - - obj = WIN32OLE::Variant.new([[1.2, "a", "b"], [3.4, "C", "D"]]) - assert_equal([[1.2, "a", "b"], [3.4, "C", "D"]], obj.value) - - obj = WIN32OLE::Variant.new([[1.2, "a", "b"], [3.4, "C", "D"], [5.6, "E", "F"]]) - assert_equal([[1.2, "a", "b"], [3.4, "C", "D"], [5.6, "E", "F"]], obj.value) - - obj = WIN32OLE::Variant.new([[[1.2], [3.4]], [[5.6], [7.8]], [[9.1],[9.2]]]) - assert_equal([[[1.2], [3.4]], [[5.6], [7.8]], [[9.1],[9.2]]], obj.value) - end - - def test_create_vt_array3 - obj = WIN32OLE::Variant.new([]) - assert_equal([], obj.value) - - obj = WIN32OLE::Variant.new([[]]) - assert_equal([[]], obj.value) - - obj = WIN32OLE::Variant.new([[],[]]) - assert_equal([[],[]], obj.value) - - obj = WIN32OLE::Variant.new([], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BYREF) - assert_equal([], obj.value) - - obj = WIN32OLE::Variant.new([[]], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BYREF) - assert_equal([[]], obj.value) - - obj = WIN32OLE::Variant.new([[],[]], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BYREF) - assert_equal([[],[]], obj.value) - end - - def test_create_vt_array_nil - vartype = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_DISPATCH|WIN32OLE::VARIANT::VT_BYREF - obj = WIN32OLE::Variant.new(nil, vartype) - assert_nil(obj.value) - assert_equal(vartype, obj.vartype) - - vartype = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_DISPATCH - obj = WIN32OLE::Variant.new(nil, vartype) - assert_nil(obj.value) - assert_equal(vartype, obj.vartype) - end - - def test_create_vt_array_str - vartype = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BSTR - obj = WIN32OLE::Variant.new(["abc", "123"], vartype) - assert_equal(vartype, obj.vartype) - assert_equal(["abc", "123"], obj.value) - - vartype = WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_BYREF|WIN32OLE::VARIANT::VT_BSTR - obj = WIN32OLE::Variant.new(["abc", "123"], vartype) - assert_equal(vartype, obj.vartype) - assert_equal(["abc", "123"], obj.value) - end - - def test_create_vt_array_exc - exc = assert_raise(TypeError) { - WIN32OLE::Variant.new("", WIN32OLE::VARIANT::VT_ARRAY) - } - assert_match(/wrong argument type String \(expected Array\)/, exc.message) - end - - def test_create_vt_array_str2ui1array - obj = WIN32OLE::Variant.new("ABC", WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1) - assert_equal("ABC", obj.value) - - obj.value = "DEF" - assert_equal("DEF", obj.value) - obj[0] = 71 - assert_equal("GEF", obj.value) - - obj = WIN32OLE::Variant.new([65, 0].pack("C*"), WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1) - assert_equal([65, 0].pack("C*"), obj.value) - - obj = WIN32OLE::Variant.new("abc", WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1|WIN32OLE::VARIANT::VT_BYREF) - assert_equal("abc", obj.value) - obj.value = "DEF" - assert_equal("DEF", obj.value) - assert_equal(WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1|WIN32OLE::VARIANT::VT_BYREF, obj.vartype) - obj[1] = 71 - assert_equal("DGF", obj.value) - - end - - def test_create_vt_array_int - obj = WIN32OLE::Variant.new([65, 0], WIN32OLE::VARIANT::VT_ARRAY|WIN32OLE::VARIANT::VT_UI1) - assert_equal([65, 0].pack("C*"), obj.value) - - obj = WIN32OLE::Variant.new([65, 0]) - assert_equal([65, 0], obj.value) - - obj = WIN32OLE::Variant.new([65, 0], WIN32OLE::VARIANT::VT_I2|WIN32OLE::VARIANT::VT_ARRAY) - assert_equal([65, 0], obj.value) - - end - - def test_vt_array_bracket - obj = WIN32OLE::Variant.new([[1,2,3],[4,5,6]]) - assert_equal(1, obj[0,0]) - assert_equal(2, obj[0,1]) - assert_equal(3, obj[0,2]) - assert_equal(4, obj[1,0]) - assert_equal(5, obj[1,1]) - assert_equal(6, obj[1,2]) - - assert_raise(WIN32OLE::RuntimeError) { - obj[0,4] - } - assert_raise(WIN32OLE::RuntimeError) { - obj[0,-1] - } - assert_raise(ArgumentError) { - obj[0] - } - - obj[0,0] = 7 - obj[1,2] = 8 - assert_equal([[7,2,3], [4,5,8]], obj.value) - - assert_raise(WIN32OLE::RuntimeError) { - obj[0,4] = 9 - } - assert_raise(WIN32OLE::RuntimeError) { - obj[0,-1] = 10 - } - assert_raise(ArgumentError) { - obj[0] = 11 - } - end - - def test_conversion_vt_date - obj = WIN32OLE::Variant.new(-657434, WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(100,1,1), obj.value) - - obj = WIN32OLE::Variant.new("1500/12/29 23:59:59", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(1500,12,29,23,59,59), obj.value) - - obj = WIN32OLE::Variant.new("1500/12/30 00:00:00", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(1500,12,30), obj.value) - - obj = WIN32OLE::Variant.new("1500/12/30 00:00:01", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(1500,12,30,0,0,1), obj.value) - - obj = WIN32OLE::Variant.new("1899/12/29 23:59:59", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(1899,12,29,23,59,59), obj.value) - - obj = WIN32OLE::Variant.new("1899/12/30 00:00:00", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(1899,12,30), obj.value) - - obj = WIN32OLE::Variant.new("1899/12/30 00:00:01", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(1899,12,30,0,0,1), obj.value) - - obj = WIN32OLE::Variant.new(0, WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(1899,12,30), obj.value) - - obj = WIN32OLE::Variant.new("2008/12/29 23:59:59", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(2008,12,29,23,59,59), obj.value) - - obj = WIN32OLE::Variant.new("2008/12/30 00:00:00", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(2008,12,30,0,0,0), obj.value) - - obj = WIN32OLE::Variant.new("2008/12/30 00:00:01", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(2008,12,30,0,0,1), obj.value) - - obj = WIN32OLE::Variant.new("9999/12/31 23:59:59", WIN32OLE::VARIANT::VT_DATE) - assert_equal(Time.new(9999,12,31,23,59,59), obj.value) - end - - def test_create_nil_dispatch - var = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_DISPATCH) - assert_nil(var.value) - end - - def test_create_variant_byref - obj = WIN32OLE::Variant.new("Str", WIN32OLE::VARIANT::VT_VARIANT|WIN32OLE::VARIANT::VT_BYREF); - assert_equal("Str", obj.value); - end - - def test_vartype - obj = WIN32OLE::Variant.new("Str") - assert_equal(WIN32OLE::VARIANT::VT_BSTR, obj.vartype) - end - - def test_set_value - obj = WIN32OLE::Variant.new(10) - obj.value = 12 - assert_equal(12, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype) - obj.value = "14" - assert_equal(14, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype) - obj.value = 11.2 - assert_equal(11, obj.value) - assert_equal(WIN32OLE::VARIANT::VT_I4, obj.vartype) - - obj = WIN32OLE::Variant.new([1,2]) - assert_raise(WIN32OLE::RuntimeError) { - obj.value = [3,4] - } - - obj = WIN32OLE::Variant.new("2007/01/01", WIN32OLE::VARIANT::VT_DATE) - assert_raise(WIN32OLE::RuntimeError) { - obj.value = "hogehoge" - } - assert_equal(Time.new(2007,1,1), obj.value) - - obj2 = WIN32OLE::Variant.new("2006/01/01", WIN32OLE::VARIANT::VT_DATE) - obj.value = obj2 - assert_equal(Time.new(2006,01,01), obj.value) - end - - def test_c_nothing - assert_nil(WIN32OLE::Variant::Nothing.value) - end - - def test_c_empty - assert_nil(WIN32OLE::Variant::Empty.value) - end - - def test_c_null - assert_nil(WIN32OLE::Variant::Null.value) - end - - def test_c_noparam - # DISP_E_PARAMNOTFOUND - assert_equal(-2147352572, WIN32OLE::Variant::NoParam.value) - end - - def test_vt_error_noparam - v = WIN32OLE::Variant.new(-1, WIN32OLE::VARIANT::VT_ERROR) - assert_equal(-1, v.value) - fso = WIN32OLE.new("Scripting.FileSystemObject") - exc = assert_raise(WIN32OLE::RuntimeError) { - fso.openTextFile("NonExistingFile", v, false) - } - assert_match(/Type mismatch/i, exc.message) - exc = assert_raise(WIN32OLE::RuntimeError) { - fso.openTextFile("NonExistingFile", WIN32OLE::Variant::NoParam, false) - } - # 800A0035 is 'file not found' error. - assert_match(/800A0035/, exc.message) - - # -2147352572 is DISP_E_PARAMNOTFOUND - v = WIN32OLE::Variant.new(-2147352572, WIN32OLE::VARIANT::VT_ERROR) - exc = assert_raise(WIN32OLE::RuntimeError) { - fso.openTextFile("NonExistingFile", WIN32OLE::Variant::NoParam, false) - } - # 800A0035 is 'file not found' error code. - assert_match(/800A0035/, exc.message) - end - - end -end - diff --git a/test/win32ole/test_win32ole_variant_m.rb b/test/win32ole/test_win32ole_variant_m.rb deleted file mode 100644 index f176d1a51e..0000000000 --- a/test/win32ole/test_win32ole_variant_m.rb +++ /dev/null @@ -1,37 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require "test/unit" - -if defined?(WIN32OLE::VARIANT) - class TestWin32OLE_VARIANT_MODULE < Test::Unit::TestCase - include WIN32OLE::VARIANT - - def test_variant - assert_equal(0, VT_EMPTY) - assert_equal(1, VT_NULL) - assert_equal(2, VT_I2) - assert_equal(3, VT_I4) - assert_equal(4, VT_R4) - assert_equal(5, VT_R8) - assert_equal(6, VT_CY) - assert_equal(7, VT_DATE) - assert_equal(8, VT_BSTR) - assert_equal(9, VT_DISPATCH) - assert_equal(10, VT_ERROR) - assert_equal(11, VT_BOOL) - assert_equal(12, VT_VARIANT) - assert_equal(13, VT_UNKNOWN) - assert_equal(16, VT_I1) - assert_equal(17, VT_UI1) - assert_equal(18, VT_UI2) - assert_equal(19, VT_UI4) - assert_equal(22, VT_INT) - assert_equal(23, VT_UINT) - assert_equal(0x2000, VT_ARRAY) - assert_equal(0x4000, VT_BYREF) - end - end -end diff --git a/test/win32ole/test_win32ole_variant_outarg.rb b/test/win32ole/test_win32ole_variant_outarg.rb deleted file mode 100644 index 9301a76aaa..0000000000 --- a/test/win32ole/test_win32ole_variant_outarg.rb +++ /dev/null @@ -1,69 +0,0 @@ -# frozen_string_literal: false -begin - require 'win32ole' -rescue LoadError -end -require 'test/unit' -require 'fileutils' - -def ado_csv_installed? - installed = false - if defined?(WIN32OLE) - db = nil - begin - db = WIN32OLE.new('ADODB.Connection') - db.connectionString = "Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;" - db.open - db.close - db = nil - installed = true - rescue - end - end - installed -end - -if defined?(WIN32OLE::Variant) - class TestWIN32OLE_VARIANT_OUTARG < Test::Unit::TestCase - module ADO - end - CONNSTR="Driver={Microsoft Text Driver (*.txt; *.csv)};DefaultDir=.;" - def setup - return if !ado_csv_installed? - - FileUtils.cp(File.dirname(__FILE__) + '/orig_data.csv', './data.csv') - @db = WIN32OLE.new('ADODB.Connection') - if !defined?(ADO::AdStateOpen) - WIN32OLE.const_load(@db, ADO) - end - @db.connectionString = CONNSTR - @db.open - end - - def test_variant_ref_and_argv - if !ado_csv_installed? - omit("ActiveX Data Object Library not found") - end - sql = "INSERT INTO data.csv VALUES (5, 'E')" - @db.execute(sql, -1) - c = WIN32OLE::ARGV[1] - assert_equal(1, c) - obj = WIN32OLE::Variant.new(nil, WIN32OLE::VARIANT::VT_VARIANT|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(nil, obj.value) - @db.execute(sql , obj) - assert_equal(1, obj.value) - obj = WIN32OLE::Variant.new(-100, WIN32OLE::VARIANT::VT_VARIANT|WIN32OLE::VARIANT::VT_BYREF) - assert_equal(-100, obj.value) - @db.execute(sql, obj) - assert_equal(1, obj.value) - end - - def teardown - return if !ado_csv_installed? - if @db && @db.state == ADO::AdStateOpen - @db.close - end - File.unlink("data.csv") - end - end -end diff --git a/test/win32ole/test_word.rb b/test/win32ole/test_word.rb deleted file mode 100644 index 34cfbbc2a4..0000000000 --- a/test/win32ole/test_word.rb +++ /dev/null @@ -1,73 +0,0 @@ -# frozen_string_literal: false -# -# This is test for [ruby-Bugs#3237] -# -begin - require 'win32ole' -rescue LoadError -end -require "test/unit" - -if defined?(WIN32OLE) - module Word; end -end - -def word_installed? - installed = false - w = nil - if defined?(WIN32OLE) - begin - w = WIN32OLE.new('Word.Application') - WIN32OLE.const_load(w, Word) - installed = true - rescue - ensure - if w - w.quit(Word::WdDoNotSaveChanges) - w = nil - end - end - end - return installed -end - -if defined?(WIN32OLE) - class TestWIN32OLE_WITH_WORD < Test::Unit::TestCase - unless word_installed? - def test_dummy_for_skip_message - omit "Microsoft Word is not installed" - end - else - def setup - begin - @obj = WIN32OLE.new('Word.Application') - rescue WIN32OLE::RuntimeError - @obj = nil - end - end - - def test_ole_methods - if @obj - @obj.visible = true - @obj.wordbasic.disableAutoMacros(true) - assert(true) - end - end - - def test_s_connect - if @obj - obj2 = WIN32OLE.connect("Word.Application") - assert_instance_of(WIN32OLE, obj2) - obj2.visible = true - end - end - - def teardown - if @obj - @obj.quit(Word::WdDoNotSaveChanges) - @obj = nil - end - end - end - end -end |