diff options
Diffstat (limited to 'ruby_1_8_6/ext/win32ole/tests')
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/oleserver.rb | 10 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/testNIL2VTEMPTY.rb | 28 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/testOLEEVENT.rb | 91 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/testOLEMETHOD.rb | 92 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/testOLEPARAM.rb | 65 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/testOLETYPE.rb | 96 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/testOLEVARIABLE.rb | 49 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/testVARIANT.rb | 32 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/testWIN32OLE.rb | 372 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/test_ole_methods.rb | 36 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/test_propertyputref.rb | 19 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/test_word.rb | 37 | ||||
-rw-r--r-- | ruby_1_8_6/ext/win32ole/tests/testall.rb | 15 |
13 files changed, 942 insertions, 0 deletions
diff --git a/ruby_1_8_6/ext/win32ole/tests/oleserver.rb b/ruby_1_8_6/ext/win32ole/tests/oleserver.rb new file mode 100644 index 0000000000..bf721373e5 --- /dev/null +++ b/ruby_1_8_6/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/ruby_1_8_6/ext/win32ole/tests/testNIL2VTEMPTY.rb b/ruby_1_8_6/ext/win32ole/tests/testNIL2VTEMPTY.rb new file mode 100644 index 0000000000..555d35fbf3 --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/testNIL2VTEMPTY.rb @@ -0,0 +1,28 @@ +# This is test script to check that WIN32OLE should convert nil to VT_EMPTY in second try. +# [ruby-talk:137054] + +require 'win32ole' +require 'test/unit' + +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) + end + end +end + diff --git a/ruby_1_8_6/ext/win32ole/tests/testOLEEVENT.rb b/ruby_1_8_6/ext/win32ole/tests/testOLEEVENT.rb new file mode 100644 index 0000000000..0901158642 --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/testOLEEVENT.rb @@ -0,0 +1,91 @@ +require 'rubyunit' +require 'win32ole' + +class TestWIN32OLE_EVENT < RUNIT::TestCase + def setup + @excel = WIN32OLE.new("Excel.Application") + @excel.visible = true + @event = "" + @event2 = "" + 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 handler1 + @event += "handler1" + end + def handler2 + @event += "handler2" + end + + def handler3 + @event += "handler3" + end + + def test_on_event2 + book = @excel.workbooks.Add + begin + ev = WIN32OLE_EVENT.new(book, 'WorkbookEvents') + ev.on_event('SheetChange'){|arg1, arg2| + handler1 + } + ev.on_event('SheetChange'){|arg1, arg2| + handler2 + } + book.Worksheets(1).Range("A1").value = "OK" + ensure + book.saved = true + end + assert_equal("handler2", @event) + end + + def test_on_event3 + book = @excel.workbooks.Add + begin + ev = WIN32OLE_EVENT.new(book, 'WorkbookEvents') + ev.on_event{ handler1 } + ev.on_event{ handler2 } + book.Worksheets(1).Range("A1").value = "OK" + ensure + book.saved = true + end + assert_equal("handler2", @event) + end + + def test_on_event4 + book = @excel.workbooks.Add + begin + ev = WIN32OLE_EVENT.new(book, 'WorkbookEvents') + ev.on_event{ handler1 } + ev.on_event{ handler2 } + ev.on_event('SheetChange'){|arg1, arg2| handler3 } + book.Worksheets(1).Range("A1").value = "OK" + ensure + book.saved = true + end + assert_equal("handler3", @event) + end + + def teardown + @excel.quit + @excel = nil + GC.start + end +end + diff --git a/ruby_1_8_6/ext/win32ole/tests/testOLEMETHOD.rb b/ruby_1_8_6/ext/win32ole/tests/testOLEMETHOD.rb new file mode 100644 index 0000000000..390c9999f8 --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/testOLEMETHOD.rb @@ -0,0 +1,92 @@ +# 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_to_s + m = WIN32OLE_METHOD.new(@excel_app, 'Quit') + assert_equal('Quit', "#{m}") + 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 + def test_dispid + tobj = WIN32OLE_TYPE.new('Microsoft Shell Controls And Automation', 'FolderItem2') + method = WIN32OLE_METHOD.new(tobj, 'InvokeVerb') + assert_equal(1610743824, method.dispid) + end +end diff --git a/ruby_1_8_6/ext/win32ole/tests/testOLEPARAM.rb b/ruby_1_8_6/ext/win32ole/tests/testOLEPARAM.rb new file mode 100644 index 0000000000..4014fadbfc --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/testOLEPARAM.rb @@ -0,0 +1,65 @@ +# 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_to_s + 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}"} + 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 +end diff --git a/ruby_1_8_6/ext/win32ole/tests/testOLETYPE.rb b/ruby_1_8_6/ext/win32ole/tests/testOLETYPE.rb new file mode 100644 index 0000000000..d4eb1146e1 --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/testOLETYPE.rb @@ -0,0 +1,96 @@ +# 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_class_to_s + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + class_names = classes.collect{|c| + "#{c}" + } + 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 + def test_to_s + type = WIN32OLE_TYPE.new(MS_EXCEL_TYPELIB, 'Application') + assert_equal("Application", "#{type}"); + end +end diff --git a/ruby_1_8_6/ext/win32ole/tests/testOLEVARIABLE.rb b/ruby_1_8_6/ext/win32ole/tests/testOLEVARIABLE.rb new file mode 100644 index 0000000000..b4bb0b57d9 --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/testOLEVARIABLE.rb @@ -0,0 +1,49 @@ +# 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_to_s + classes = WIN32OLE_TYPE.ole_classes(MS_EXCEL_TYPELIB) + chart = classes.find {|c| c.name == 'XlChartType'} + var_names = chart.variables.collect {|m| "#{m}"} + 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/ruby_1_8_6/ext/win32ole/tests/testVARIANT.rb b/ruby_1_8_6/ext/win32ole/tests/testVARIANT.rb new file mode 100644 index 0000000000..f274778f27 --- /dev/null +++ b/ruby_1_8_6/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/ruby_1_8_6/ext/win32ole/tests/testWIN32OLE.rb b/ruby_1_8_6/ext/win32ole/tests/testWIN32OLE.rb new file mode 100644 index 0000000000..5c01507377 --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/testWIN32OLE.rb @@ -0,0 +1,372 @@ +# 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_s_codepage + assert_equal(WIN32OLE::CP_ACP, WIN32OLE.codepage) + end + + def test_s_codepage_set + WIN32OLE.codepage = WIN32OLE::CP_UTF8 + assert_equal(WIN32OLE::CP_UTF8, WIN32OLE.codepage) + WIN32OLE.codepage = WIN32OLE::CP_ACP + 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_s_codepage_changed + book = @excel.workbooks.add + sheet = book.worksheets(1) + begin + WIN32OLE.codepage = WIN32OLE::CP_UTF8 + sheet.range("A1").value = [0x3042].pack("U*") + val = sheet.range("A1").value + assert_equal("\343\201\202", val) + WIN32OLE.codepage = WIN32OLE::CP_ACP + val = sheet.range("A1").value + assert_equal("\202\240", val) + ensure + book.saved = true + end + 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) + assert_equal(10, sheet['Cells', 1, 2].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_func_methods + methods = @excel.ole_func_methods + assert(methods.size > 0) + method_names = methods.collect{|m| m.name} + assert(method_names.include?("Quit")) + end + def test_ole_put_methods + methods = @excel.ole_put_methods + assert(methods.size > 0) + method_names = methods.collect{|m| m.name} + assert(method_names.include?("Visible")) + end + def test_ole_get_methods + methods = @excel.ole_get_methods + assert(methods.size > 0) + method_names = methods.collect{|m| m.name} + assert(method_names.include?("Visible")) + 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 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 + + def test__invoke + shell=WIN32OLE.new('Shell.Application') + assert_equal(shell.NameSpace(0).title, shell._invoke(0x60020002, [0], [WIN32OLE::VARIANT::VT_VARIANT]).title) + end +end + +# --------------------- +# +# a subclass of Win32OLE +# override new() and connect() +class MyExcel<WIN32OLE + def MyExcel.new + super "Excel.Application" + end + def MyExcel.connect + super "Excel.Application" + end +end + +class TestMyExcel < TestWin32OLE +# +# because we overrided new() and connect() +# we need to change the test. +# also, because the class will be different +# + def setup + @excel = MyExcel.new + @excel.visible = true + end + def test_s_new + assert_instance_of(MyExcel, @excel) + end + def test_s_connect + excel2 = MyExcel.connect + assert_instance_of(MyExcel, excel2) + end +# +# const_load didn't like to be called twice, +# and I don't know how to undefine something in Ruby yet +# so, hide the test. +# + private :test_s_const_load +end + +if $0 == __FILE__ + puts "Now Test Win32OLE version #{WIN32OLE::VERSION}" + if ARGV.size == 0 + suite = RUNIT::TestSuite.new + suite.add_test(TestWin32OLE.suite) + suite.add_test(TestMyExcel.suite) + begin + installer = WIN32OLE.new("WindowsInstaller.Installer") + suite.add_test(TestWin32OLE_WITH_MSI.suite) + rescue + puts "Skip some test with MSI" + end + else + suite = RUNIT::TestSuite.new + ARGV.each do |testmethod| + suite.add_test(TestWin32OLE.new(testmethod)) + end + end + RUNIT::CUI::TestRunner.quiet_mode = true + RUNIT::CUI::TestRunner.run(suite) +end diff --git a/ruby_1_8_6/ext/win32ole/tests/test_ole_methods.rb b/ruby_1_8_6/ext/win32ole/tests/test_ole_methods.rb new file mode 100644 index 0000000000..ca1c03b010 --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/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/ruby_1_8_6/ext/win32ole/tests/test_propertyputref.rb b/ruby_1_8_6/ext/win32ole/tests/test_propertyputref.rb new file mode 100644 index 0000000000..befc35ca9c --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/test_propertyputref.rb @@ -0,0 +1,19 @@ +require 'test/unit' +require 'win32ole' + +class TestWIN32OLE_PROPERTYPUTREF < Test::Unit::TestCase + def setup + begin + @sapi = WIN32OLE.new('SAPI.SpVoice') + rescue WIN32OLERuntimeError + @sapi = nil + end + end + def test_sapi + if @sapi + new_id = @sapi.getvoices.item(2).Id + @sapi.voice = @sapi.getvoices.item(2) + assert_equal(new_id, @sapi.voice.Id) + end + end +end diff --git a/ruby_1_8_6/ext/win32ole/tests/test_word.rb b/ruby_1_8_6/ext/win32ole/tests/test_word.rb new file mode 100644 index 0000000000..53a6c521ba --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/test_word.rb @@ -0,0 +1,37 @@ +# +# This is test for [ruby-Bugs#3237] +# +begin + require 'win32ole' +rescue LoadError +end +require "test/unit" + +if defined?(WIN32OLE) + class TestWIN32OLE_WITH_WORD < Test::Unit::TestCase + + def setup + begin + @obj = WIN32OLE.new('Word.Application') + rescue WIN32OLERuntimeError + @obj = nil + end + end + + def test_ole_methods + if @obj + @obj.visible = true + @obj.wordbasic.disableAutoMacros(true) + assert(true) + end + end + + def teardown + if @obj + @obj.quit + @obj = nil + end + end + + end +end diff --git a/ruby_1_8_6/ext/win32ole/tests/testall.rb b/ruby_1_8_6/ext/win32ole/tests/testall.rb new file mode 100644 index 0000000000..d45541f571 --- /dev/null +++ b/ruby_1_8_6/ext/win32ole/tests/testall.rb @@ -0,0 +1,15 @@ +require 'rubyunit' +require 'win32ole' +puts "Now Test Win32OLE version #{WIN32OLE::VERSION}" +# RUNIT::CUI::TestRunner.quiet_mode = true +require "testWIN32OLE" +require "testOLETYPE" +require "testOLEPARAM" +require "testOLEMETHOD" +require "testOLEVARIABLE" +require "testVARIANT" +require "testNIL2VTEMPTY" +require "test_ole_methods.rb" +require "test_propertyputref.rb" +require "test_word.rb" +# require "testOLEEVENT" |