From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/test/win32ole/err_in_callback.rb | 9 + jni/ruby/test/win32ole/orig_data.csv | 5 + jni/ruby/test/win32ole/test_err_in_callback.rb | 55 ++ .../test/win32ole/test_folderitem2_invokeverb.rb | 65 ++ jni/ruby/test/win32ole/test_nil2vtempty.rb | 36 + jni/ruby/test/win32ole/test_ole_methods.rb | 36 + jni/ruby/test/win32ole/test_propertyputref.rb | 30 + jni/ruby/test/win32ole/test_thread.rb | 33 + jni/ruby/test/win32ole/test_win32ole.rb | 564 ++++++++++++++++ jni/ruby/test/win32ole/test_win32ole_event.rb | 391 +++++++++++ jni/ruby/test/win32ole/test_win32ole_method.rb | 146 +++++ jni/ruby/test/win32ole/test_win32ole_param.rb | 106 +++ jni/ruby/test/win32ole/test_win32ole_record.rb | 313 +++++++++ jni/ruby/test/win32ole/test_win32ole_type.rb | 249 +++++++ jni/ruby/test/win32ole/test_win32ole_typelib.rb | 116 ++++ jni/ruby/test/win32ole/test_win32ole_variable.rb | 61 ++ jni/ruby/test/win32ole/test_win32ole_variant.rb | 725 +++++++++++++++++++++ jni/ruby/test/win32ole/test_win32ole_variant_m.rb | 35 + .../test/win32ole/test_win32ole_variant_outarg.rb | 68 ++ jni/ruby/test/win32ole/test_word.rb | 71 ++ 20 files changed, 3114 insertions(+) create mode 100644 jni/ruby/test/win32ole/err_in_callback.rb create mode 100644 jni/ruby/test/win32ole/orig_data.csv create mode 100644 jni/ruby/test/win32ole/test_err_in_callback.rb create mode 100644 jni/ruby/test/win32ole/test_folderitem2_invokeverb.rb create mode 100644 jni/ruby/test/win32ole/test_nil2vtempty.rb create mode 100644 jni/ruby/test/win32ole/test_ole_methods.rb create mode 100644 jni/ruby/test/win32ole/test_propertyputref.rb create mode 100644 jni/ruby/test/win32ole/test_thread.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_event.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_method.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_param.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_record.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_type.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_typelib.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_variable.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_variant.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_variant_m.rb create mode 100644 jni/ruby/test/win32ole/test_win32ole_variant_outarg.rb create mode 100644 jni/ruby/test/win32ole/test_word.rb (limited to 'jni/ruby/test/win32ole') diff --git a/jni/ruby/test/win32ole/err_in_callback.rb b/jni/ruby/test/win32ole/err_in_callback.rb new file mode 100644 index 0000000..fabb7be --- /dev/null +++ b/jni/ruby/test/win32ole/err_in_callback.rb @@ -0,0 +1,9 @@ +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/jni/ruby/test/win32ole/orig_data.csv b/jni/ruby/test/win32ole/orig_data.csv new file mode 100644 index 0000000..3931c6a --- /dev/null +++ b/jni/ruby/test/win32ole/orig_data.csv @@ -0,0 +1,5 @@ +ID,VALUE +1,"A" +2,"B" +3,"C" +4,"B" diff --git a/jni/ruby/test/win32ole/test_err_in_callback.rb b/jni/ruby/test/win32ole/test_err_in_callback.rb new file mode 100644 index 0000000..cae6d49 --- /dev/null +++ b/jni/ruby/test/win32ole/test_err_in_callback.rb @@ -0,0 +1,55 @@ +# +# 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 WIN32OLERuntimeError + return false + end + return true + end + + def test_err_in_callback + skip "'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/jni/ruby/test/win32ole/test_folderitem2_invokeverb.rb b/jni/ruby/test/win32ole/test_folderitem2_invokeverb.rb new file mode 100644 index 0000000..c5ec88c --- /dev/null +++ b/jni/ruby/test/win32ole/test_folderitem2_invokeverb.rb @@ -0,0 +1,65 @@ +# +# 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/jni/ruby/test/win32ole/test_nil2vtempty.rb b/jni/ruby/test/win32ole/test_nil2vtempty.rb new file mode 100644 index 0000000..8508ecd --- /dev/null +++ b/jni/ruby/test/win32ole/test_nil2vtempty.rb @@ -0,0 +1,36 @@ +# 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/jni/ruby/test/win32ole/test_ole_methods.rb b/jni/ruby/test/win32ole/test_ole_methods.rb new file mode 100644 index 0000000..869828d --- /dev/null +++ b/jni/ruby/test/win32ole/test_ole_methods.rb @@ -0,0 +1,36 @@ +# +# 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(x.size > 0) + 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(x.size > 0) + assert_equal(1, x.size) + assert_equal('Item', x[0].name) + end + + end +end diff --git a/jni/ruby/test/win32ole/test_propertyputref.rb b/jni/ruby/test/win32ole/test_propertyputref.rb new file mode 100644 index 0000000..24459af --- /dev/null +++ b/jni/ruby/test/win32ole/test_propertyputref.rb @@ -0,0 +1,30 @@ +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 WIN32OLERuntimeError + @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/jni/ruby/test/win32ole/test_thread.rb b/jni/ruby/test/win32ole/test_thread.rb new file mode 100644 index 0000000..56a6357 --- /dev/null +++ b/jni/ruby/test/win32ole/test_thread.rb @@ -0,0 +1,33 @@ +begin + require 'win32ole' +rescue LoadError +end +require 'test/unit' + +if defined?(WIN32OLE) + class TestThread < 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(WIN32OLERuntimeError, "[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/jni/ruby/test/win32ole/test_win32ole.rb b/jni/ruby/test/win32ole/test_win32ole.rb new file mode 100644 index 0000000..b41fd59 --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole.rb @@ -0,0 +1,564 @@ +# coding: us-ascii + +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(WIN32OLERuntimeError) { + @dict1.unknown_property = 1 + } + end + + def test_raise_message + exc = assert_raise(WIN32OLERuntimeError) { + @dict1.add + } + assert_match(/^\(in OLE method `add': \)/, exc.message) #` + + exc = assert_raise(WIN32OLERuntimeError) { + @dict1._invoke(1, [], []) + } + assert_match(/^\(in OLE method `': \)/, exc.message) #` + + exc = assert_raise(WIN32OLERuntimeError) { + @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) + end + + def test_ole_methods + methods = @dict1.ole_methods + mnames = methods.collect {|m| + m.name + } + assert(mnames.include?("Add")) + end + + def test_ole_func_methods + methods = @dict1.ole_func_methods + mnames = methods.collect {|m| + m.name + } + assert(mnames.include?("Add")) + end + + def test_ole_put_methods + methods = @dict1.ole_put_methods + mnames = methods.collect {|m| + m.name + } + assert(mnames.include?("CompareMode")) + end + + def test_ole_get_methods + methods = @dict1.ole_get_methods + mnames = methods.collect {|m| + m.name + } + assert(mnames.include?("Count")) + end + + def test_ole_mehtod_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_exc_svr_tainted + th = Thread.start { + $SAFE = 1 + svr = "Scripting.Dictionary" + svr.taint + WIN32OLE.new(svr) + } + exc = assert_raise(SecurityError) { + th.join + } + assert_match(/insecure object creation - `Scripting.Dictionary'/, exc.message) + end + + def test_s_new_exc_host_tainted + th = Thread.start { + $SAFE = 1 + svr = "Scripting.Dictionary" + host = "localhost" + host.taint + WIN32OLE.new(svr, host) + } + exc = assert_raise(SecurityError) { + th.join + } + assert_match(/insecure object creation - `localhost'/, exc.message) + 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(WIN32OLERuntimeError) { + 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_s_coonect_exc_tainted + th = Thread.start { + $SAFE = 1 + svr = "winmgmts:" + svr.taint + WIN32OLE.connect(svr) + } + exc = assert_raise(SecurityError) { + th.join + } + assert_match(/insecure connection - `winmgmts:'/, exc.message) + 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 + } + 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 + 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 WIN32OLERuntimeError + end + if (WIN32OLE.codepage == 932) + assert_equal("\x82\xA0".force_encoding("CP932"), obj.value) + end + + begin + WIN32OLE.codepage = 20932 # MS EUC-JP + rescue WIN32OLERuntimeError + 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 WIN32OLERuntimeError + 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 WIN32OLERuntimeError + 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(WIN32OLERuntimeError) { + 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 WIN32OLERuntimeError + end + if WIN32OLE.locale == 0x0411 + obj = WIN32OLE_VARIANT.new("\\100,000", WIN32OLE::VARIANT::VT_CY) + assert_equal("100000", obj.value) + assert_raise(WIN32OLERuntimeError) { + 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 WIN32OLERuntimeError + 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/jni/ruby/test/win32ole/test_win32ole_event.rb b/jni/ruby/test/win32ole/test_win32ole_event.rb new file mode 100644 index 0000000..86004cd --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_event.rb @@ -0,0 +1,391 @@ +begin + require 'win32ole' +rescue LoadError +end +require 'test/unit' + +def ado_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 + +def swbemsink_avairable? + available = false + if defined?(WIN32OLE) + wmi = nil + begin + wmi = WIN32OLE.new('WbemScripting.SWbemSink') + available = true + rescue + end + end + available +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 + + class TestWIN32OLE_EVENT_SWbemSink < Test::Unit::TestCase + unless swbemsink_avairable? + def test_dummy_for_skip_message + skip "'WbemScripting.SWbemSink' is not available" + end + else + 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 + 2.times do + WIN32OLE_EVENT.message_loop + sleep 1 + 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 + @wmi.ExecNotificationQueryAsync(@sws, @sql) + 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 + assert_match(/OnObjectReady/, @event) + end + + def test_on_event + @wmi.ExecNotificationQueryAsync(@sws, @sql) + ev = WIN32OLE_EVENT.new(@sws, 'ISWbemSinkEvents') + ev.on_event {|*args| default_handler(*args)} + message_loop + assert_match(/OnObjectReady/, @event) + end + + def test_on_event_symbol + @wmi.ExecNotificationQueryAsync(@sws, @sql) + ev = WIN32OLE_EVENT.new(@sws) + ev.on_event(:OnObjectReady) {|*args| + handler1 + } + message_loop + assert_equal("handler1", @event1) + end + + end + end + + class TestWIN32OLE_EVENT_ADO < Test::Unit::TestCase + unless ado_installed? + def test_dummy_for_skip_message + skip "ActiveX Data Object Library not found" + end + else + 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(WIN32OLERuntimeError) { + 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(WIN32OLERuntimeError) { + @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 + + def test_s_new_exc_tainted + th = Thread.new { + $SAFE=1 + str = 'ConnectionEvents' + str.taint + ev = WIN32OLE_EVENT.new(@db, str) + } + exc = assert_raise(SecurityError) { + th.join + } + assert_match(/insecure event creation - `ConnectionEvents'/, exc.message) + end + end + end +end diff --git a/jni/ruby/test/win32ole/test_win32ole_method.rb b/jni/ruby/test/win32ole/test_win32ole_method.rb new file mode 100644 index 0000000..2a4e3d0 --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_method.rb @@ -0,0 +1,146 @@ +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") + + ole_type = WIN32OLE_TYPE.new("Microsoft Internet Controls", "WebBrowser") + @m_navigate_complete = WIN32OLE_METHOD.new(ole_type, "NavigateComplete") + 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(WIN32OLERuntimeError) { + 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_event? + assert(@m_navigate_complete.event?) + assert(!@m_namespace.event?) + end + + def test_event_interface + assert_equal("DWebBrowserEvents", @m_navigate_complete.event_interface) + assert_equal(nil, @m_namespace.event_interface) + 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("#", @m_namespace.inspect) + end + + end +end diff --git a/jni/ruby/test/win32ole/test_win32ole_param.rb b/jni/ruby/test/win32ole/test_win32ole_param.rb new file mode 100644 index 0000000..1a4eeff --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_param.rb @@ -0,0 +1,106 @@ +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 Internet Controls", "WebBrowser") + m_navigate = WIN32OLE_METHOD.new(ole_type, "Navigate") + m_before_navigate = WIN32OLE_METHOD.new(ole_type, "BeforeNavigate") + params = m_navigate.params + @param_url = params[0] + @param_flags = params[1] + @param_cancel = m_before_navigate.params[5] + + 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_overwritefiles = m_copyfile.params[2] + 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); + } + 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("#", param.inspect) + end + + def test_name + assert_equal('URL', @param_url.name) + assert_equal('Flags', @param_flags.name) + assert_equal('Cancel', @param_cancel.name) + end + + def test_ole_type + assert_equal('BSTR', @param_url.ole_type) + assert_equal('VARIANT', @param_flags.ole_type) + end + + def test_ole_type_detail + assert_equal(['BSTR'], @param_url.ole_type_detail) + assert_equal(['PTR', 'VARIANT'], @param_flags.ole_type_detail) + end + + def test_input? + assert(@param_url.input?) + assert(@param_cancel.input?) + assert(!@param_pbs.input?) + end + + def test_output? + assert(!@param_url.output?) + assert(@param_cancel.output?) + assert(@param_pbs.output?) + end + + def test_optional? + assert(!@param_url.optional?) + assert(@param_flags.optional?) + end + + def test_retval? + assert(!@param_url.retval?) + assert(@param_p.retval?) + end + + def test_default + assert_equal(nil, @param_url.default) + assert_equal(true, @param_overwritefiles.default) + end + + def test_to_s + assert_equal(@param_url.name, @param_url.to_s) + end + + def test_inspect + assert_equal("#", @param_url.inspect) + assert_equal("#", @param_overwritefiles.inspect) + end + end +end diff --git a/jni/ruby/test/win32ole/test_win32ole_record.rb b/jni/ruby/test/win32ole/test_win32ole_record.rb new file mode 100644 index 0000000..265feb8 --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_record.rb @@ -0,0 +1,313 @@ +# coding: us-ascii + +begin + require 'win32ole' +rescue LoadError +end +require 'test/unit' + +PROGID_CLR='System.Runtime.Serialization.FormatterConverter' +PROGID_RBCOMTEST='RbComTest.ComSrvTest' + +=begin +RbComTest.ComSrvTest is following VB.NET COM server(RbComTest solution). + +Imports System.Runtime.InteropServices +Public Class ComSrvTest + _ + Public Structure Book + _ + 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( 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( ByRef book As Book) + book.title = "The Ruby Reference Book2" + book.cost = 44 + End Sub + + Public Sub getVer3BookByRefBook( ByRef book As Book) + book.title += " ver3" + book.cost *= 1.2 + End Sub +End Class +=end + + +if defined?(WIN32OLE_RECORD) + def rbcomtest_exist? + exist = false + begin + obj = WIN32OLE.new(PROGID_RBCOMTEST) + exist = true + rescue WIN32OLERuntimeError + exist = false + end + exist + end + + class TestWIN32OLE_RECORD_BY_RBCOMTEST < Test::Unit::TestCase + unless rbcomtest_exist? + def test_dummy_for_skip_message + skip "#{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(WIN32OLERuntimeError) { + rec = WIN32OLE_RECORD.new('NonExistRecordName', @obj) + } + assert_raise(ArgumentError) { + rec = WIN32OLE_RECORD.new + } + assert_raise(ArgumentError) { + rec = 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('ComObject', @obj) + assert_equal(nil, obj.ole_instance_variable_get(:object_id)) + assert_equal(nil, obj.ole_instance_variable_get('object_id')) + 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[#nil, "cost"=>nil}>], book.inspect) + end + end + end + + def clr_exist? + exist = false + begin + obj = WIN32OLE.new(PROGID_CLR) + exist = true + rescue WIN32OLERuntimeError + exist = false + end + exist + end + + class TestWIN32OLE_CLR < Test::Unit::TestCase + unless clr_exist? + def test_dummy_for_skip_message + skip "#{PROGID_CLR}(.Net Framework 3.5) not found." + end + else + def setup + @obj = WIN32OLE.new(PROGID_CLR) + end + + def test_s_new_from_win32ole + rec = WIN32OLE_RECORD.new('Decimal', @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('Decimal', tlib) + assert(rec) + assert_instance_of(WIN32OLE_RECORD, rec) + end + + def test_s_new_raise + assert_raise(WIN32OLERuntimeError) { + rec = WIN32OLE_RECORD.new('NonExistRecordName', @obj) + } + assert_raise(ArgumentError) { + rec = WIN32OLE_RECORD.new + } + assert_raise(ArgumentError) { + rec = WIN32OLE_RECORD.new('NonExistRecordName') + } + end + + def test_to_h + rec = WIN32OLE_RECORD.new('Decimal', @obj) + assert_equal({'lo'=>nil, 'mid'=>nil, 'hi'=>nil, 'flags'=>nil}, rec.to_h) + end + + def test_typename + rec = WIN32OLE_RECORD.new('Decimal', @obj) + assert_equal('Decimal', rec.typename) + end + + def test_method_missing_getter + rec = WIN32OLE_RECORD.new('Decimal', @obj) + assert_equal(nil, rec.lo) + assert_raise(KeyError) { + rec.non_exist_name + } + end + + def test_method_missing_setter + rec = WIN32OLE_RECORD.new('Decimal', @obj) + rec.lo = 1 + assert_equal(1, rec.lo) + end + + def test_pass_record_parameter + rec = WIN32OLE_RECORD.new('Decimal', @obj) + rec.lo = 0 + rec.mid = 1 + rec.hi = 0 + rec.flags = false + assert_equal(2**32, @obj.ToInt64(rec)) + end + + def test_ole_instance_variable_get + obj = WIN32OLE_RECORD.new('Decimal', @obj) + assert_equal(nil, obj.ole_instance_variable_get(:lo)) + assert_equal(nil, obj.ole_instance_variable_get('lo')) + end + + def test_ole_instance_variable_set + rec = WIN32OLE_RECORD.new('Decimal', @obj) + rec.ole_instance_variable_set(:lo, 1) + assert_equal(1, rec.lo) + rec.ole_instance_variable_set('lo', 2) + assert_equal(2, rec.lo) + end + + def test_inspect + rec = WIN32OLE_RECORD.new('Decimal', @obj) + assert_equal(%q[#nil, "hi"=>nil, "lo"=>nil, "mid"=>nil}>], rec.inspect) + end + + end + end + +end diff --git a/jni/ruby/test/win32ole/test_win32ole_type.rb b/jni/ruby/test/win32ole/test_win32ole_type.rb new file mode 100644 index 0000000..5422352 --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_type.rb @@ -0,0 +1,249 @@ +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(WIN32OLERuntimeError) { + WIN32OLE_TYPE.new("Microsoft Shell Controls And Automation", "foo") + } + assert_raise(WIN32OLERuntimeError) { + 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) + + ie_otype = WIN32OLE_TYPE.new("Microsoft Internet Controls", "InternetExplorer") + ole_types = ie_otype.implemented_ole_types + assert_equal(4, ole_types.size) + otype = ole_types.select{|t| t.name == "IWebBrowser2"} + assert_equal(1, otype.size) + otype = ole_types.select{|t| t.name == "IWebBrowserApp"} + assert_equal(1, otype.size) + otype = ole_types.select{|t| t.name == "DWebBrowserEvents2"} + assert_equal(1, otype.size) + otype = ole_types.select{|t| t.name == "DWebBrowserEvents"} + assert_equal(1, otype.size) + end + + def test_default_ole_types + ie_otype = WIN32OLE_TYPE.new("Microsoft Internet Controls", "InternetExplorer") + ole_types = ie_otype.default_ole_types + otype = ole_types.select{|t| t.name == "IWebBrowser2"} + assert_equal(1, otype.size) + otype = ole_types.select{|t| t.name == "IWebBrowserApp"} + assert_equal(0, otype.size) + otype = ole_types.select{|t| t.name == "DWebBrowserEvents2"} + assert_equal(1, otype.size) + otype = ole_types.select{|t| t.name == "DWebBrowserEvents"} + assert_equal(0, otype.size) + end + + def test_source_ole_types + ie_otype = WIN32OLE_TYPE.new("Microsoft Internet Controls", "InternetExplorer") + ole_types = ie_otype.source_ole_types + otype = ole_types.select{|t| t.name == "IWebBrowser2"} + assert_equal(0, otype.size) + otype = ole_types.select{|t| t.name == "IWebBrowserApp"} + assert_equal(0, otype.size) + otype = ole_types.select{|t| t.name == "DWebBrowserEvents2"} + assert_equal(1, otype.size) + otype = ole_types.select{|t| t.name == "DWebBrowserEvents"} + assert_equal(1, otype.size) + end + + def test_default_event_sources + ie_otype = WIN32OLE_TYPE.new("Microsoft Internet Controls", "InternetExplorer") + ole_types = ie_otype.default_event_sources + otype = ole_types.select{|t| t.name == "IWebBrowser2"} + assert_equal(0, otype.size) + otype = ole_types.select{|t| t.name == "IWebBrowserApp"} + assert_equal(0, otype.size) + otype = ole_types.select{|t| t.name == "DWebBrowserEvents2"} + assert_equal(1, otype.size) + otype = ole_types.select{|t| t.name == "DWebBrowserEvents"} + assert_equal(0, otype.size) + end + + def test_inspect + assert_equal("#", @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/jni/ruby/test/win32ole/test_win32ole_typelib.rb b/jni/ruby/test/win32ole/test_win32ole_typelib.rb new file mode 100644 index 0000000..a548bc1 --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_typelib.rb @@ -0,0 +1,116 @@ +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(WIN32OLERuntimeError) { + 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("#", tlib.inspect) + end + + end +end diff --git a/jni/ruby/test/win32ole/test_win32ole_variable.rb b/jni/ruby/test/win32ole/test_win32ole_variable.rb new file mode 100644 index 0000000..5fdcb07 --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_variable.rb @@ -0,0 +1,61 @@ +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_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("#", @var1.inspect) + assert_equal("#", @var2.inspect) + end + + end +end diff --git a/jni/ruby/test/win32ole/test_win32ole_variant.rb b/jni/ruby/test/win32ole/test_win32ole_variant.rb new file mode 100644 index 0000000..9583a01 --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_variant.rb @@ -0,0 +1,725 @@ +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 + ex = nil + begin + WIN32OLE_VARIANT.new + rescue ArgumentError + ex = $! + end + assert_instance_of(ArgumentError, ex) + assert_equal("wrong number of arguments (0 for 1..3)", ex.message); + 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 WIN32OLERuntimeError + skip("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(1, WIN32OLE::VARIANT::VT_ARRAY); + } + assert_match(/wrong argument type Fixnum \(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(WIN32OLERuntimeError) { + obj[0,4] + } + assert_raise(WIN32OLERuntimeError) { + 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(WIN32OLERuntimeError) { + obj[0,4] = 9 + } + assert_raise(WIN32OLERuntimeError) { + 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(WIN32OLERuntimeError) { + obj.value = [3,4] + } + + obj = WIN32OLE_VARIANT.new("2007/01/01", WIN32OLE::VARIANT::VT_DATE) + assert_raise(WIN32OLERuntimeError) { + 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(WIN32OLERuntimeError) { + fso.openTextFile("NonExistingFile", v, false) + } + assert_match(/Type mismatch/i, exc.message) + exc = assert_raise(WIN32OLERuntimeError) { + 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(WIN32OLERuntimeError) { + 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/jni/ruby/test/win32ole/test_win32ole_variant_m.rb b/jni/ruby/test/win32ole/test_win32ole_variant_m.rb new file mode 100644 index 0000000..b3e48c2 --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_variant_m.rb @@ -0,0 +1,35 @@ +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/jni/ruby/test/win32ole/test_win32ole_variant_outarg.rb b/jni/ruby/test/win32ole/test_win32ole_variant_outarg.rb new file mode 100644 index 0000000..ffc8e06 --- /dev/null +++ b/jni/ruby/test/win32ole/test_win32ole_variant_outarg.rb @@ -0,0 +1,68 @@ +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? + skip("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/jni/ruby/test/win32ole/test_word.rb b/jni/ruby/test/win32ole/test_word.rb new file mode 100644 index 0000000..acfa214 --- /dev/null +++ b/jni/ruby/test/win32ole/test_word.rb @@ -0,0 +1,71 @@ +# +# This is test for [ruby-Bugs#3237] +# +begin + require 'win32ole' +rescue LoadError +end +require "test/unit" + +def word_installed? + installed = false + w = nil + if defined?(WIN32OLE) + begin + w = WIN32OLE.new('Word.Application') + installed = true + rescue + ensure + if w + w.quit + w = nil + end + end + end + return installed +end + +if defined?(WIN32OLE) + dotest = word_installed? + if !dotest + STDERR.puts("\n#{__FILE__} skipped(Microsoft Word not found.)") + end + if dotest + class TestWIN32OLE_WITH_WORD < Test::Unit::TestCase + def setup + begin + @obj = WIN32OLE.new('Word.Application') + rescue WIN32OLERuntimeError + @obj = nil + if !$skipped + $skipped = true + end + end + end + + def test_ole_methods + if @obj + @obj.visible = true + @obj.wordbasic.disableAutoMacros(true) + assert(true) + else + 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 + @obj = nil + end + end + end + end +end -- cgit v1.2.3