From f14180707d83a9e15106952102d1853b441edabd Mon Sep 17 00:00:00 2001 From: suke Date: Sat, 1 Jun 2002 12:34:30 +0000 Subject: merge win32ole from rough git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2508 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ext/win32ole/tests/oleserver.rb | 10 ++ ext/win32ole/tests/testOLEEVENT.rb | 33 ++++ ext/win32ole/tests/testOLEMETHOD.rb | 83 ++++++++++ ext/win32ole/tests/testOLEPARAM.rb | 67 ++++++++ ext/win32ole/tests/testOLETYPE.rb | 83 ++++++++++ ext/win32ole/tests/testOLEVARIABLE.rb | 42 +++++ ext/win32ole/tests/testVARIANT.rb | 32 ++++ ext/win32ole/tests/testWIN32OLE.rb | 298 ++++++++++++++++++++++++++++++++++ ext/win32ole/tests/testall.rb | 11 ++ 9 files changed, 659 insertions(+) create mode 100644 ext/win32ole/tests/oleserver.rb create mode 100644 ext/win32ole/tests/testOLEEVENT.rb create mode 100644 ext/win32ole/tests/testOLEMETHOD.rb create mode 100644 ext/win32ole/tests/testOLEPARAM.rb create mode 100644 ext/win32ole/tests/testOLETYPE.rb create mode 100644 ext/win32ole/tests/testOLEVARIABLE.rb create mode 100644 ext/win32ole/tests/testVARIANT.rb create mode 100644 ext/win32ole/tests/testWIN32OLE.rb create mode 100644 ext/win32ole/tests/testall.rb (limited to 'ext/win32ole/tests') diff --git a/ext/win32ole/tests/oleserver.rb b/ext/win32ole/tests/oleserver.rb new file mode 100644 index 0000000000..bf721373e5 --- /dev/null +++ b/ext/win32ole/tests/oleserver.rb @@ -0,0 +1,10 @@ +require 'win32ole' +def oletypelib_name(pat) + WIN32OLE_TYPE.typelibs.each do |lib| + return lib if pat =~ lib + end +end +module OLESERVER + MS_EXCEL_TYPELIB = oletypelib_name(/^Microsoft Excel .* Object Library$/) + MS_XML_TYPELIB = oletypelib_name(/^Microsoft XML/) +end diff --git a/ext/win32ole/tests/testOLEEVENT.rb b/ext/win32ole/tests/testOLEEVENT.rb new file mode 100644 index 0000000000..15b7ca8413 --- /dev/null +++ b/ext/win32ole/tests/testOLEEVENT.rb @@ -0,0 +1,33 @@ +require 'rubyunit' +require 'win32ole' + +class TestWIN32OLE_EVENT < RUNIT::TestCase + def setup + @excel = WIN32OLE.new("Excel.Application") + @excel.visible = true + end + def test_on_event + book = @excel.workbooks.Add + value = "" + begin + ev = WIN32OLE_EVENT.new(book, 'WorkbookEvents') + ev.on_event('SheetChange'){|arg1, arg2| + begin + value = arg1.value + rescue + value = $!.message + end + } + book.Worksheets(1).Range("A1").value = "OK" + ensure + book.saved = true + end + assert_equal("OK", value) + end + def teardown + @excel.quit + @excel = nil + GC.start + end +end + diff --git a/ext/win32ole/tests/testOLEMETHOD.rb b/ext/win32ole/tests/testOLEMETHOD.rb new file mode 100644 index 0000000000..4f65ec96b4 --- /dev/null +++ b/ext/win32ole/tests/testOLEMETHOD.rb @@ -0,0 +1,83 @@ +# You need RubyUnit and MS Excel and MSI to run this test script + +require 'rubyunit' + +require 'win32ole' +require 'oleserver' + +class TestOLEMETHOD < RUNIT::TestCase + include OLESERVER + def setup + @excel_app = WIN32OLE_TYPE.new(MS_EXCEL_TYPELIB, 'Application') + end + def test_s_new + m = WIN32OLE_METHOD.new(@excel_app, 'Quit') + assert_instance_of(WIN32OLE_METHOD, m) + m = WIN32OLE_METHOD.new(@excel_app, 'WorkbookOpen') + assert_instance_of(WIN32OLE_METHOD, m) + m = WIN32OLE_METHOD.new(@excel_app, 'workbookopen') + assert_instance_of(WIN32OLE_METHOD, m) + end + def test_name + m = WIN32OLE_METHOD.new(@excel_app, 'Quit') + assert_equal('Quit', m.name) + end + def test_return_type + m = WIN32OLE_METHOD.new(@excel_app, 'ActiveCell') + assert_equal('Range', m.return_type) + m = WIN32OLE_METHOD.new(@excel_app, 'ActivePrinter') + assert_equal('BSTR', m.return_type) + end + def test_return_vtype + m = WIN32OLE_METHOD.new(@excel_app, 'ActiveCell') + assert_equal(WIN32OLE::VARIANT::VT_PTR, m.return_vtype) + m = WIN32OLE_METHOD.new(@excel_app, 'ActivePrinter') + assert_equal(WIN32OLE::VARIANT::VT_BSTR, m.return_vtype) + end + def test_return_type_detail + m = WIN32OLE_METHOD.new(@excel_app, 'ActiveCell') + assert_equal(['PTR', 'USERDEFINED', 'Range'], m.return_type_detail) + m = WIN32OLE_METHOD.new(@excel_app, 'ActivePrinter') + assert_equal(['BSTR'], m.return_type_detail) + end + + def test_invoke_kind + m = WIN32OLE_METHOD.new(@excel_app, 'ActiveCell') + assert_equal('PROPERTYGET', m.invoke_kind) + end + def test_visible + m = WIN32OLE_METHOD.new(@excel_app, 'ActiveCell') + assert(m.visible?) + m = WIN32OLE_METHOD.new(@excel_app, 'AddRef') + assert(!m.visible?) + end + def test_event + m = WIN32OLE_METHOD.new(@excel_app, 'WorkbookOpen') + assert(m.event?) + m = WIN32OLE_METHOD.new(@excel_app, 'ActiveCell') + assert(!m.event?) + end + def test_event_interface + m = WIN32OLE_METHOD.new(@excel_app, 'WorkbookOpen') + assert_equal('AppEvents', m.event_interface) + m = WIN32OLE_METHOD.new(@excel_app, 'ActiveCell') + assert_nil(m.event_interface) + end + def test_helpstring + domdoc = WIN32OLE_TYPE.new(MS_XML_TYPELIB, 'DOMDocument') + m = WIN32OLE_METHOD.new(domdoc, 'abort') + assert_equal('abort an asynchronous download', m.helpstring) + end + def test_helpfile + m = WIN32OLE_METHOD.new(@excel_app, 'ActiveCell') + assert_match(/VBAXL.*\.(HLP|CHM)$/i, m.helpfile) + end + def test_helpcontext + m = WIN32OLE_METHOD.new(@excel_app, 'ActiveCell') + assert(m.helpcontext > 0) + end + def test_offset_vtbl + m = WIN32OLE_METHOD.new(@excel_app, 'QueryInterface') + assert_equal(0, m.offset_vtbl) + end +end diff --git a/ext/win32ole/tests/testOLEPARAM.rb b/ext/win32ole/tests/testOLEPARAM.rb new file mode 100644 index 0000000000..62fd2a1890 --- /dev/null +++ b/ext/win32ole/tests/testOLEPARAM.rb @@ -0,0 +1,67 @@ +# You need RubyUnit and MS Excel and MSI to run this test script + +require 'rubyunit' + +require 'win32ole' +require 'oleserver' + +class TestOLEPARAM < RUNIT::TestCase + include OLESERVER + def test_name + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + sh = classes.find {|c| c.name == 'Worksheet'} + saveas = sh.ole_methods.find {|m| m.name == 'SaveAs'} + param_names = saveas.params.collect{|p| p.name} + assert(param_names.size > 0) + assert(param_names.include?('Filename')) + end + def test_ole_type + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + methods = classes.find {|c| c.name == 'Worksheet'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert_equal('BSTR', f.params[0].ole_type) + methods = classes.find {|c| c.name == 'Workbook'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert_equal('XlSaveAsAccessMode', f.params[6].ole_type) + end + def test_ole_type_detail + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + methods = classes.find {|c| c.name == 'Worksheet'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert_equal(['BSTR'], f.params[0].ole_type_detail) + methods = classes.find {|c| c.name == 'Workbook'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert_equal(['USERDEFINED', 'XlSaveAsAccessMode'], f.params[6].ole_type_detail) + end + def test_input + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + methods = classes.find {|c| c.name == 'Worksheet'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert(f.params[0].input?) + end + + def test_output + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + methods = classes.find {|c| c.name == 'Worksheet'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert(!f.params[0].output?) + end + def test_optional + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + methods = classes.find {|c| c.name == 'Worksheet'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert(!f.params[0].optional?) + methods = classes.find {|c| c.name == 'Workbook'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert(f.params[0].optional?) + end + def test_ole_type_detail + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + methods = classes.find {|c| c.name == 'Worksheet'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert_equal(nil, f.params[0].default) + methods = classes.find {|c| c.name == 'Workbook'}.ole_methods + f = methods.find {|m| m.name == 'SaveAs'} + assert_equal(1, f.params[6].default) + end +end diff --git a/ext/win32ole/tests/testOLETYPE.rb b/ext/win32ole/tests/testOLETYPE.rb new file mode 100644 index 0000000000..9840aac940 --- /dev/null +++ b/ext/win32ole/tests/testOLETYPE.rb @@ -0,0 +1,83 @@ +# You need RubyUnit and MS Excel and MSI to run this test script + +require 'rubyunit' + +require 'win32ole' +require 'oleserver' + +class TestOLETYPE < RUNIT::TestCase + include OLESERVER + def test_s_new + type = WIN32OLE_TYPE.new(MS_EXCEL_TYPELIB, 'Application') + assert_instance_of(WIN32OLE_TYPE, type) + end + def test_s_ole_classes + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + assert(classes.size > 0) + end + def test_s_typelibs + libs = WIN32OLE_TYPE.typelibs + assert(libs.include?(MS_EXCEL_TYPELIB)) + assert(libs.include?(MS_XML_TYPELIB)) + end + def test_s_progids + progids = WIN32OLE_TYPE.progids + assert(progids.include?('Excel.Application')) + end + def test_name + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + class_names = classes.collect{|c| + c.name + } + assert(class_names.include?('Application')) + end + def test_ole_type + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + app = classes.find {|c| c.name == 'Application'} + assert_equal('Class', app.ole_type) + app = classes.find {|c| c.name == '_Application'} + assert_equal('Dispatch', app.ole_type) + end + def test_typekind + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + app = classes.find {|c| c.name == 'Application'} + assert_equal(5, app.typekind) + end + def test_visible + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + app = classes.find {|c| c.name == 'Application'} + assert(app.visible?) + app = classes.find {|c| c.name == 'IAppEvents'} + assert(!app.visible?) + end + def test_src_type + classes = WIN32OLE_TYPE.ole_classes(MS_XML_TYPELIB) + domnode = classes.find {|c| c.name == 'DOMNodeType'} + assert_equal('tagDOMNodeType', domnode.src_type) + end + def test_helpstring + classes = WIN32OLE_TYPE.ole_classes(MS_XML_TYPELIB) + domdoc = classes.find {|c| c.name == 'DOMDocument'} + assert_equal('W3C-DOM XML Document', domdoc.helpstring) + end + def test_variables + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + xlchart = classes.find {|c| c.name == 'XlChartType'} + assert(xlchart.variables.size > 0) + end + def test_ole_methods + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + worksheet = classes.find {|c| c.name == 'Worksheet'} + assert(worksheet.ole_methods.size > 0) + end + def test_helpfile + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + worksheet = classes.find {|c| c.name == 'Worksheet'} + assert_match(/VBAXL.*\.(CHM|HLP)$/, worksheet.helpfile) + end + def test_helpcontext + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + worksheet = classes.find {|c| c.name == 'Worksheet'} + assert_equal(131088, worksheet.helpcontext) + end +end diff --git a/ext/win32ole/tests/testOLEVARIABLE.rb b/ext/win32ole/tests/testOLEVARIABLE.rb new file mode 100644 index 0000000000..b237d9b616 --- /dev/null +++ b/ext/win32ole/tests/testOLEVARIABLE.rb @@ -0,0 +1,42 @@ +# You need RubyUnit and MS Excel and MSI to run this test script + +require 'rubyunit' + +require 'win32ole' +require 'oleserver' + +class TestOLEVARIABLE < RUNIT::TestCase + include OLESERVER + def test_name + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + chart = classes.find {|c| c.name == 'XlChartType'} + var_names = chart.variables.collect {|m| m.name} + assert(var_names.size > 0) + assert(var_names.include?('xl3DColumn')) + end + def test_ole_type + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + chart = classes.find {|c| c.name == 'XlChartType'} + var = chart.variables.find {|m| m.name == 'xl3DColumn'} + assert_equal('INT', var.ole_type) + end + def test_ole_type_detail + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + chart = classes.find {|c| c.name == 'XlChartType'} + var = chart.variables.find {|m| m.name == 'xl3DColumn'} + assert_equal(['INT'], var.ole_type_detail) + end + + def test_value + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + chart = classes.find {|c| c.name == 'XlChartType'} + var = chart.variables.find {|m| m.name == 'xl3DColumn'} + assert_equal(-4100, var.value) + end + def test_visible + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + chart = classes.find {|c| c.name == 'XlChartType'} + var = chart.variables.find {|m| m.name == 'xl3DColumn'} + assert(var.visible?) + end +end diff --git a/ext/win32ole/tests/testVARIANT.rb b/ext/win32ole/tests/testVARIANT.rb new file mode 100644 index 0000000000..f274778f27 --- /dev/null +++ b/ext/win32ole/tests/testVARIANT.rb @@ -0,0 +1,32 @@ +# You need RubyUnit and MS Excel and MSI to run this test script + +require 'rubyunit' + +require 'win32ole' + +class TestWin32OLE_VARIANT < RUNIT::TestCase + include WIN32OLE::VARIANT + def test_variant + 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 + diff --git a/ext/win32ole/tests/testWIN32OLE.rb b/ext/win32ole/tests/testWIN32OLE.rb new file mode 100644 index 0000000000..7907fe36a9 --- /dev/null +++ b/ext/win32ole/tests/testWIN32OLE.rb @@ -0,0 +1,298 @@ +# You need RubyUnit and MS Excel and MSI to run this test script + +require 'runit/testcase' +require 'runit/cui/testrunner' + +require 'win32ole' +require 'oleserver' + +module EXCEL_CONST +end + +module CONST1 +end + +module CONST2 +end + +module CONST3 +end + +class TestWin32OLE < RUNIT::TestCase + include OLESERVER + def setup + @excel = WIN32OLE.new("Excel.Application") + @excel.visible = true + end + def test_s_new + assert_instance_of(WIN32OLE, @excel) + end + def test_s_new_DCOM + rexcel = WIN32OLE.new("Excel.Application", "localhost") + assert_instance_of(WIN32OLE, rexcel) + rexcel.visible = true + rexcel.quit + end + def test_s_new_from_clsid + excel = WIN32OLE.new("{00024500-0000-0000-C000-000000000046}") + assert_instance_of(WIN32OLE, excel) + excel.quit + exc = assert_exception(WIN32OLERuntimeError) { + WIN32OLE.new("{000}") + } + assert_match(/Unknown OLE server : `\{000\}'/, exc.message) + end + def test_s_connect + excel2 = WIN32OLE.connect('Excel.Application') + assert_instance_of(WIN32OLE, excel2) + end + + def test_s_const_load + assert(!defined?(EXCEL_CONST::XlTop)) + WIN32OLE.const_load(@excel, EXCEL_CONST) + assert_equal(-4160, EXCEL_CONST::XlTop) + + assert(!defined?(CONST1::XlTop)) + WIN32OLE.const_load(MS_EXCEL_TYPELIB, CONST1) + assert_equal(-4160, CONST1::XlTop) + end + + def test_get_win32ole_object + workbooks = @excel.Workbooks; + assert_instance_of(WIN32OLE, workbooks) + end + def test_each + workbooks = @excel.Workbooks + assert_no_exception { + i = 0; + workbooks.each do |workbook| + print i += 1 + end + } + workbooks.add + workbooks.add + i = 0 + workbooks.each do |workbook| + i+=1 + end + assert_equal(2, i) + workbooks.each do |workbook| + workbook.saved = true + end + end + def test_setproperty_bracket + book = @excel.workbooks.add + sheet = book.worksheets(1) + begin + sheet.range("A1")['Value'] = 10 + assert_equal(10, sheet.range("A1").value) + sheet['Cells', 1, 2] = 10 + assert_equal(10, sheet.range("B1").value) + ensure + book.saved = true + end + end + def test_convert_bignum + book = @excel.workbooks.add + sheet = book.worksheets(1) + begin + sheet.range("A1").value = 999999999 + sheet.range("A2").value = 9999999999 + sheet.range("A3").value = "=A1*10 + 9" + assert_equal(9999999999, sheet.range("A2").value) + assert_equal(9999999999, sheet.range("A3").value) + + ensure + book.saved = true + end + end + + def test_ole_invoke_with_named_arg + book = @excel.workbooks.add + sheets = book.worksheets + sheet = book.worksheets(1) + num = sheets.count + begin + sheets.add({'count' => 2, 'after'=>sheet}) + assert_equal(2, sheets.count - num); + ensure + book.saved = true + end + end + + def test_ole_invoke_with_named_arg_last + book = @excel.workbooks.add + sheets = book.worksheets + sheet = book.worksheets(1) + num = sheets.count + begin + sheets.add(sheet, {'count' => 2}) + assert_equal(2, sheets.count - num); + ensure + book.saved = true + end + end + + def test_setproperty + @excel.setproperty('Visible', false) + assert_equal(false, @excel.Visible) + @excel.setproperty('Visible', true) + assert_equal(true, @excel.Visible) + book = @excel.workbooks.add + sheet = book.worksheets(1) + begin + sheet.setproperty('Cells', 1, 2, 10) + assert_equal(10, sheet.range("B1").value) + ensure + book.saved = true + end + end + def test_no_exist_property + isok = false + begin + @excel.unknown_prop = 1 + rescue WIN32OLERuntimeError + isok = true + end + assert(isok) + + isok = false + begin + @excel['unknown_prop'] = 2 + rescue WIN32OLERuntimeError + isok = true + end + assert(isok) + end + + def test_setproperty_with_equal + book = @excel.workbooks.add + sheet = book.worksheets(1) + begin + sheet.range("B1").value = 10 + assert_equal(10, sheet.range("B1").value) + sheet.range("C1:D1").value = [11, 12] + assert_equal(11, sheet.range("C1").value) + assert_equal(12, sheet.range("D1").value) + ensure + book.saved = true + end + end + def test_invoke + workbooks = @excel.invoke( 'workbooks' ) + assert_instance_of(WIN32OLE, workbooks) + book = workbooks.invoke( 'add' ) + assert_instance_of(WIN32OLE, book) + end + def test_ole_methods + methods = @excel.ole_methods + method_names = methods.collect{|m| m.name} + assert(method_names.include?("Quit")) + end + def test_ole_method_help + quit_info = @excel.ole_method_help("Quit") + assert_equal(0, quit_info.size_params) + assert_equal(0, quit_info.size_opt_params) + + workbooks = @excel.Workbooks + add_info = workbooks.ole_method_help("Add") + assert_equal(1, add_info.size_params) + assert_equal(1, add_info.size_opt_params) + assert(add_info.params[0].input?) + assert(add_info.params[0].optional?) + assert_equal('VARIANT', add_info.params[0].ole_type) + end +# def test_ole_put_methods +# methods_list = @excel.ole_put_methods +# puts methods_list +# end + def teardown + @excel.quit + @excel = nil + GC.start + end +end + +class TestWin32OLE_WITH_MSI < RUNIT::TestCase + def setup + installer = WIN32OLE.new("WindowsInstaller.Installer") + @record = installer.CreateRecord(2) + end + + # Sorry, this test fails. + # Win32OLE does not support this style to set property. + # Use Win32OLE#setproperty or Win32OLE#[]= . + # def test_invoke + # @record.invoke("StringData", 1, 'cccc') + # assert_equal('cccc', @record.StringData(1)) + # end + + def test_setproperty + @record.setproperty( "StringData", 1, 'dddd') + assert_equal('dddd', @record.StringData(1)) + end + def test_bracket_equal_with_arg + @record[ "StringData", 1 ] = 'ffff' + assert_equal('ffff', @record.StringData(1)) + end +end + +# --------------------- +# +# a subclass of Win32OLE +# override new() and connect() +class MyExcel