r2corba 1.5.5 → 1.6.0

data/test/OBV/Truncatable/client.rb

@@ -23,22 +23,22 @@ ARGV.options do |opts|
     script_name = File.basename($0)
     opts.banner = "Usage: ruby #{script_name} [options]"
 
-    opts.separator ""
+    opts.separator ''
 
-    opts.on("--k IORFILE",
-            "Set IOR.",
+    opts.on('--k IORFILE',
+            'Set IOR.',
             "Default: 'file://server.ior'") { |v| OPTIONS[:iorfile] = v }
-    opts.on("--d LVL",
-            "Set ORBDebugLevel value.",
-            "Default: 0") { |v| OPTIONS[:orb_debuglevel] = v }
-    opts.on("--use-implement",
-            "Load IDL through CORBA.implement() instead of precompiled code.",
-            "Default: off") { |v| OPTIONS[:use_implement] = v }
+    opts.on('--d LVL',
+            'Set ORBDebugLevel value.',
+            'Default: 0') { |v| OPTIONS[:orb_debuglevel] = v }
+    opts.on('--use-implement',
+            'Load IDL through CORBA.implement() instead of precompiled code.',
+            'Default: off') { |v| OPTIONS[:use_implement] = v }
 
-    opts.separator ""
+    opts.separator ''
 
-    opts.on("-h", "--help",
-            "Show this help message.") { puts opts; exit }
+    opts.on('-h', '--help',
+            'Show this help message.') { puts opts; exit }
 
     opts.parse!
 end
@@ -50,7 +50,7 @@ else
   require 'ExtraC'
 end
 
-orb = CORBA.ORB_init(["-ORBDebugLevel", OPTIONS[:orb_debuglevel]], 'myORB')
+orb = CORBA.ORB_init(['-ORBDebugLevel', OPTIONS[:orb_debuglevel]], 'myORB')
 
 begin
   # make sure valuetype factories are registered
@@ -69,7 +69,7 @@ begin
   assert_not 'Object reference is nil.', CORBA::is_nil(tester)
 
   if defined?(JRUBY_VERSION)
-    STDERR.puts "Skipping. Value type truncation currently not properly supported by JacORB!"
+    STDERR.puts 'Skipping. Value type truncation currently not properly supported by JacORB!'
     tester.shutdown
     exit 0
   end
@@ -79,13 +79,13 @@ begin
   v1.basic_data = 9
   v1.data1 = 99
 
-  desc = "A<-tB, truncate B to A"
+  desc = 'A<-tB, truncate B to A'
   STDERR.print "Case 1: #{desc}: "
 
-  ov1, odesc = tester.op1("case1", v1, desc)
+  ov1, odesc = tester.op1('case1', v1, desc)
 
   assert '\nERROR: tester.op1 desc FAILED', odesc == "case1: #{desc}"
-  assert '\nERROR: tester.op1 ov FAILED' , v1.basic_data == ov1.basic_data
+  assert '\nERROR: tester.op1 ov FAILED', v1.basic_data == ov1.basic_data
 
   STDERR.puts 'passed'
 
@@ -95,23 +95,23 @@ begin
   v2.data1 = 99
   v2.data2 = 99 * 2
 
-  desc = "A<-tB<-tC, truncate C to A"
+  desc = 'A<-tB<-tC, truncate C to A'
   STDERR.print "Case 2: #{desc}: "
 
-  ov2, odesc = tester.op1("case2", v2, desc)
+  ov2, odesc = tester.op1('case2', v2, desc)
 
   assert '\nERROR: tester.op1 - 2 desc FAILED', odesc == "case2: #{desc}"
-  assert '\nERROR: tester.op1 - 2 ov FAILED' , v2.basic_data == ov2.basic_data
+  assert '\nERROR: tester.op1 - 2 ov FAILED', v2.basic_data == ov2.basic_data
   STDERR.puts 'passed'
 
-  desc = "A<-tB<-tC, truncate C to B"
+  desc = 'A<-tB<-tC, truncate C to B'
   STDERR.print "Case 2b: #{desc}: "
 
-  otv1, odesc = tester.op2(v2, "case2b", desc)
+  otv1, odesc = tester.op2(v2, 'case2b', desc)
 
   assert '\nERROR: tester.op2 - 2b desc FAILED', odesc == "case2b: #{desc}"
-  assert '\nERROR: tester.op2 - 2b otv1 FAILED' , v2.basic_data == otv1.basic_data
-  assert '\nERROR: tester.op2 - 2b otv1 FAILED' , v2.data1 == otv1.data1
+  assert '\nERROR: tester.op2 - 2b otv1 FAILED', v2.basic_data == otv1.basic_data
+  assert '\nERROR: tester.op2 - 2b otv1 FAILED', v2.data1 == otv1.data1
   STDERR.puts 'passed'
 
   # 3.
@@ -119,14 +119,14 @@ begin
   itv1b.basic_data = 7
   itv1b.data1 = 8
 
-  desc = "A<-tB, truncatable but no truncation"
+  desc = 'A<-tB, truncatable but no truncation'
   STDERR.print "Case 3: #{desc}: "
 
-  otv1b, odesc = tester.op2(itv1b, "case3", desc)
+  otv1b, odesc = tester.op2(itv1b, 'case3', desc)
 
   assert '\nERROR: tester.op2 - 3 desc FAILED', odesc == "case3: #{desc}"
-  assert '\nERROR: tester.op2 - 3 otv1b FAILED' , itv1b.basic_data == otv1b.basic_data
-  assert '\nERROR: tester.op2 - 3 otv1b FAILED' , itv1b.data1 == otv1b.data1
+  assert '\nERROR: tester.op2 - 3 otv1b FAILED', itv1b.basic_data == otv1b.basic_data
+  assert '\nERROR: tester.op2 - 3 otv1b FAILED', itv1b.data1 == otv1b.data1
   STDERR.puts 'passed'
 
   # 4.
@@ -136,9 +136,9 @@ begin
   v3.data3 = (99 * 3)
 
   begin
-    desc = "A<-tB<-C, try truncate C to A, MARSHAL exception"
+    desc = 'A<-tB<-C, try truncate C to A, MARSHAL exception'
     STDERR.print "Case 4: #{desc}: "
-    ov3, odesc = tester.op1("case4", v3, desc)
+    ov3, odesc = tester.op1('case4', v3, desc)
     STDERR.puts 'failed'
   rescue CORBA::MARSHAL
     STDERR.puts 'passed'
@@ -153,39 +153,39 @@ begin
   v5.basic_data = 9
   v5.nv4 = nv
   v5.data4 = (99 * 4)
-  v5.str1 = "str1"
+  v5.str1 = 'str1'
   v5.data5 = (99 * 5)
   v5.nv5 = nv
-  v5.str2 = "str2"
+  v5.str2 = 'str2'
 
-  desc = "A<-tB<-tC, B & C have nested value type, truncate C to A"
+  desc = 'A<-tB<-tC, B & C have nested value type, truncate C to A'
   STDERR.print "Case 5: #{desc}: "
-  ov5, odesc = tester.op1("case5", v5, desc)
+  ov5, odesc = tester.op1('case5', v5, desc)
 
   assert '\nERROR: tester.op1 - 5 desc FAILED', odesc == "case5: #{desc}"
-  assert '\nERROR: tester.op1 - 5 ov5 FAILED' , v5.basic_data == ov5.basic_data
+  assert '\nERROR: tester.op1 - 5 ov5 FAILED', v5.basic_data == ov5.basic_data
   STDERR.puts 'passed'
 
-  desc = "A<-tB<-tC, B & C have nested value type, truncate C to B"
+  desc = 'A<-tB<-tC, B & C have nested value type, truncate C to B'
   STDERR.print "Case 5b: #{desc}: "
-  otv4, odesc = tester.op3("case5b", v5, desc)
+  otv4, odesc = tester.op3('case5b', v5, desc)
 
   assert '\nERROR: tester.op3 - 5b desc FAILED', odesc == "case5b: #{desc}"
-  assert '\nERROR: tester.op3 - 5b otv4 FAILED' , v5.basic_data == otv4.basic_data
-  assert '\nERROR: tester.op3 - 5b otv4.nv4 FAILED' , v5.nv4.data == otv4.nv4.data
-  assert '\nERROR: tester.op3 - 5b otv4.data4 FAILED' , v5.data4 == otv4.data4
+  assert '\nERROR: tester.op3 - 5b otv4 FAILED', v5.basic_data == otv4.basic_data
+  assert '\nERROR: tester.op3 - 5b otv4.nv4 FAILED', v5.nv4.data == otv4.nv4.data
+  assert '\nERROR: tester.op3 - 5b otv4.data4 FAILED', v5.data4 == otv4.data4
   STDERR.puts 'passed'
 
   # 6.
   iv = OBV_TruncatableTest::TValue6.new
   iv.basic_data = 9
 
-  desc = "A<-tB, B has no data, truncate B to A"
+  desc = 'A<-tB, B has no data, truncate B to A'
   STDERR.print "Case 6: #{desc}: "
-  ov, odesc = tester.op1("case6", iv, desc)
+  ov, odesc = tester.op1('case6', iv, desc)
 
   assert '\nERROR: tester.op1 - 6 desc FAILED', odesc == "case6: #{desc}"
-  assert '\nERROR: tester.op1 - 6 ov FAILED' , iv.basic_data == ov.basic_data
+  assert '\nERROR: tester.op1 - 6 ov FAILED', iv.basic_data == ov.basic_data
   STDERR.puts 'passed'
 
   # 7.
@@ -210,15 +210,15 @@ begin
   v3.nv4 = nv
   v3.data4 = 66
 
-  desc = "multiple IN truncatable valuetype parameters" +
-         " and return truncatable valuetype"
+  desc = 'multiple IN truncatable valuetype parameters' +
+         ' and return truncatable valuetype'
   STDERR.print "Case 7: #{desc}: "
-  ov, odesc = tester.op4("case7", v1, 5, v2, v3, v4, desc)
+  ov, odesc = tester.op4('case7', v1, 5, v2, v3, v4, desc)
 
   assert '\nERROR: tester.op4 - 7 desc FAILED', odesc == "case7: #{desc}"
   total = 5 * (v1.basic_data + v2.basic_data +
                v3.basic_data + v4.basic_data)
-  assert '\nERROR: tester.op4 - 7 ov FAILED' ,  total == ov.basic_data
+  assert '\nERROR: tester.op4 - 7 ov FAILED',  total == ov.basic_data
   STDERR.puts 'passed'
 
   # 8.
@@ -227,12 +227,12 @@ begin
   v1.data1 = 99
   v1.edata1 = 1234
 
-  desc = "A<-tB, truncate unknown B to A"
+  desc = 'A<-tB, truncate unknown B to A'
   STDERR.print "Case 8: #{desc}: "
-  ov1, odesc = tester.op2(v1, "case8", desc)
+  ov1, odesc = tester.op2(v1, 'case8', desc)
 
   assert '\nERROR: tester.op2 - 8 desc FAILED', odesc == "case8: #{desc}"
-  assert '\nERROR: tester.op2 - 8 ov1 FAILED' , v1.basic_data == ov1.basic_data &&
+  assert '\nERROR: tester.op2 - 8 ov1 FAILED', v1.basic_data == ov1.basic_data &&
                                                 v1.data1 == ov1.data1
   STDERR.puts 'passed'
 
@@ -242,12 +242,12 @@ begin
   v1.data1 = 99
 
   a = CORBA::Any.to_any(v1)
-  desc = "A<-tB, known truncatable via Any"
+  desc = 'A<-tB, known truncatable via Any'
   STDERR.print "Case 9: #{desc}: "
-  ov1, odesc = tester.op5(a, "case9", desc)
+  ov1, odesc = tester.op5(a, 'case9', desc)
 
   assert '\nERROR: tester.op5 - 9 desc FAILED', odesc == "case9: #{desc}"
-  assert '\nERROR: tester.op5 - 9 ov1 FAILED' , v1.basic_data == ov1.basic_data &&
+  assert '\nERROR: tester.op5 - 9 ov1 FAILED', v1.basic_data == ov1.basic_data &&
                                                 v1.data1 == ov1.data1
   STDERR.puts 'passed'
 
@@ -258,12 +258,12 @@ begin
   v1.edata1 = 1234
 
   a = CORBA::Any.to_any(v1)
-  desc = "A<-tB, unknown truncatable via Any"
+  desc = 'A<-tB, unknown truncatable via Any'
   STDERR.print "Case 10: #{desc}: "
-  ov1, odesc = tester.op5(a, "case10", desc)
+  ov1, odesc = tester.op5(a, 'case10', desc)
 
   assert '\nERROR: tester.op5 - 10 desc FAILED', odesc == "case10: #{desc}"
-  assert '\nERROR: tester.op5 - 10 ov1 FAILED' , v1.basic_data == ov1.basic_data &&
+  assert '\nERROR: tester.op5 - 10 ov1 FAILED', v1.basic_data == ov1.basic_data &&
                                                  v1.data1 == ov1.data1
   STDERR.puts 'passed'
 

data/test/OBV/Truncatable/run_test.rb

@@ -20,19 +20,19 @@ ARGV.options do |opts|
     script_name = File.basename($0)
     opts.banner = "Usage: ruby #{script_name} [options]"
 
-    opts.separator ""
+    opts.separator ''
 
-    opts.on("-d",
-            "Run with debugging output.",
-            "Default: false") { OPTIONS[:debug_opt] = '--d 10' }
-    opts.on("--use-stubs",
-            "Use stubs generated by RIDL.",
-            "Default: false (uses embedded IDL)") { OPTIONS[:use_implement] = '' }
+    opts.on('-d',
+            'Run with debugging output.',
+            'Default: false') { OPTIONS[:debug_opt] = '--d 10' }
+    opts.on('--use-stubs',
+            'Use stubs generated by RIDL.',
+            'Default: false (uses embedded IDL)') { OPTIONS[:use_implement] = '' }
 
-    opts.separator ""
+    opts.separator ''
 
-    opts.on("-h", "--help",
-            "Show this help message.") { puts opts; exit }
+    opts.on('-h', '--help',
+            'Show this help message.') { puts opts; exit }
 
     opts.parse!
 end

data/test/OBV/Truncatable/server.rb

@@ -21,22 +21,22 @@ ARGV.options do |opts|
     script_name = File.basename($0)
     opts.banner = "Usage: ruby #{script_name} [options]"
 
-    opts.separator ""
+    opts.separator ''
 
-    opts.on("--o IORFILE",
-            "Set IOR filename.",
+    opts.on('--o IORFILE',
+            'Set IOR filename.',
             "Default: 'server.ior'") { |v| OPTIONS[:iorfile] = v }
-    opts.on("--d LVL",
-            "Set ORBDebugLevel value.",
-            "Default: 0") { |v| OPTIONS[:orb_debuglevel] = v }
-    opts.on("--use-implement",
-            "Load IDL through CORBA.implement() instead of precompiled code.",
-            "Default: off") { |v| OPTIONS[:use_implement] = v }
+    opts.on('--d LVL',
+            'Set ORBDebugLevel value.',
+            'Default: 0') { |v| OPTIONS[:orb_debuglevel] = v }
+    opts.on('--use-implement',
+            'Load IDL through CORBA.implement() instead of precompiled code.',
+            'Default: off') { |v| OPTIONS[:use_implement] = v }
 
-    opts.separator ""
+    opts.separator ''
 
-    opts.on("-h", "--help",
-            "Show this help message.") { puts opts; exit }
+    opts.on('-h', '--help',
+            'Show this help message.') { puts opts; exit }
 
     opts.parse!
 end
@@ -50,7 +50,7 @@ end
 
 require 'Truncatable_impl'
 
-orb = CORBA.ORB_init(["-ORBDebugLevel", OPTIONS[:orb_debuglevel]], 'myORB')
+orb = CORBA.ORB_init(['-ORBDebugLevel', OPTIONS[:orb_debuglevel]], 'myORB')
 
 # make sure valuetype factories are registered
 OBV_TruncatableTest::BaseValueFactory.get_factory(orb)
@@ -77,7 +77,7 @@ open(OPTIONS[:iorfile], 'w') { |io|
 }
 
 Signal.trap('INT') do
-  puts "SIGINT - shutting down ORB..."
+  puts 'SIGINT - shutting down ORB...'
   orb.shutdown()
 end
 

data/test/OBV/ValueBox/client.rb

@@ -23,22 +23,22 @@ ARGV.options do |opts|
     script_name = File.basename($0)
     opts.banner = "Usage: ruby #{script_name} [options]"
 
-    opts.separator ""
+    opts.separator ''
 
-    opts.on("--k IORFILE",
-            "Set IOR.",
+    opts.on('--k IORFILE',
+            'Set IOR.',
             "Default: 'file://server.ior'") { |v| OPTIONS[:iorfile] = v }
-    opts.on("--d LVL",
-            "Set ORBDebugLevel value.",
-            "Default: 0") { |v| OPTIONS[:orb_debuglevel] = v }
-    opts.on("--use-implement",
-            "Load IDL through CORBA.implement() instead of precompiled code.",
-            "Default: off") { |v| OPTIONS[:use_implement] = v }
+    opts.on('--d LVL',
+            'Set ORBDebugLevel value.',
+            'Default: 0') { |v| OPTIONS[:orb_debuglevel] = v }
+    opts.on('--use-implement',
+            'Load IDL through CORBA.implement() instead of precompiled code.',
+            'Default: off') { |v| OPTIONS[:use_implement] = v }
 
-    opts.separator ""
+    opts.separator ''
 
-    opts.on("-h", "--help",
-            "Show this help message.") { puts opts; exit }
+    opts.on('-h', '--help',
+            'Show this help message.') { puts opts; exit }
 
     opts.parse!
 end
@@ -64,9 +64,9 @@ module Test
     STDERR.puts '*** basic_op1 (1)'
     retval, p2_out, p3_out = test.basic_op1(p1, p2)
 
-    assert "basic_invocations:1 failed", (p2_out == (53 * 3))
-    assert "basic_invocations:1 failed", (p3_out == (53 * 5))
-    assert "basic_invocations:1 failed", (retval == (p1.value * 3))
+    assert 'basic_invocations:1 failed', (p2_out == (53 * 3))
+    assert 'basic_invocations:1 failed', (p3_out == (53 * 5))
+    assert 'basic_invocations:1 failed', (retval == (p1.value * 3))
 
     # test boxed value using implicit conversion of Ruby types
     p1 = 25
@@ -78,9 +78,9 @@ module Test
     STDERR.puts '*** basic_op1 (2)'
     retval, p2_out, p3_out = test.basic_op1(p1, p2)
 
-    assert "basic_invocations:2 failed", (p2_out == (53 * 3))
-    assert "basic_invocations:2 failed", (p3_out == (53 * 5))
-    assert "basic_invocations:2 failed", (retval == (p1 * 3))
+    assert 'basic_invocations:2 failed', (p2_out == (53 * 3))
+    assert 'basic_invocations:2 failed', (p3_out == (53 * 5))
+    assert 'basic_invocations:2 failed', (retval == (p1 * 3))
 
     # test boxed value using nil
     p1 = nil
@@ -92,9 +92,9 @@ module Test
     STDERR.puts '*** basic_op1 (3)'
     retval, p2_out, p3_out = test.basic_op1(p1, p2)
 
-    assert "basic_invocations:2 failed", (p2_out == (53 * 3))
-    assert "basic_invocations:2 failed", (p3_out == (53 * 5))
-    assert "basic_invocations:2 failed", (retval.nil?)
+    assert 'basic_invocations:2 failed', (p2_out == (53 * 3))
+    assert 'basic_invocations:2 failed', (p3_out == (53 * 5))
+    assert 'basic_invocations:2 failed', (retval.nil?)
 
     # test boxed value from nested module
     p1 = Vb_basic::M_VBlong.new(25) # explicit value box
@@ -105,9 +105,9 @@ module Test
 
     retval, p2_out, p3_out = test.basic_op2(p1, p2)
 
-    assert "basic_invocations:3 failed", (p2_out == (53 * 3))
-    assert "basic_invocations:3 failed", (p3_out == (53 * 5))
-    assert "basic_invocations:3 failed", (retval == (p1.value * 3))
+    assert 'basic_invocations:3 failed', (p2_out == (53 * 3))
+    assert 'basic_invocations:3 failed', (p3_out == (53 * 5))
+    assert 'basic_invocations:3 failed', (retval == (p1.value * 3))
 
     # test regular Ruby types using values from valueboxes
     p1 = VBlong.new(25)
@@ -118,71 +118,71 @@ module Test
 
     retval, p2_out, p3_out = test.basic_op3(p1.value, p2.value)
 
-    assert "basic_invocations:4 failed", (p2_out == (53 * 3))
-    assert "basic_invocations:4 failed", (p3_out == (53 * 5))
-    assert "basic_invocations:4 failed", (retval == (p1.value * 3))
+    assert 'basic_invocations:4 failed', (p2_out == (53 * 3))
+    assert 'basic_invocations:4 failed', (p3_out == (53 * 5))
+    assert 'basic_invocations:4 failed', (retval == (p1.value * 3))
   end
 
   def Test.boxed_string_invocations(test)
-    string1 = "First-string"
-    string2 = "Second-string"
+    string1 = 'First-string'
+    string2 = 'Second-string'
 
     # Establish that we have data setup correctly...
-    assert "boxed_string_invocations:0 failed", (string1 < string2)
-    assert "boxed_string_invocations:0 failed", (string2 > string1)
-    assert "boxed_string_invocations:0 failed", (string1 == string1)
+    assert 'boxed_string_invocations:0 failed', (string1 < string2)
+    assert 'boxed_string_invocations:0 failed', (string2 > string1)
+    assert 'boxed_string_invocations:0 failed', (string1 == string1)
 
     # create valueboxes
     vbstring1 = VBstring.new(string1.dup)
     vbstring2 = VBstring.new(string1.dup)
 
     # check valuebox correctness
-    assert "boxed_string_invocations:1 failed", (vbstring1.value == string1)
-    assert "boxed_string_invocations:1 failed", (vbstring2.value == string1)
+    assert 'boxed_string_invocations:1 failed', (vbstring1.value == string1)
+    assert 'boxed_string_invocations:1 failed', (vbstring2.value == string1)
 
     # test value modifier
     vbstring2.value = string2.dup
-    assert "boxed_string_invocations:2 failed", (vbstring2.value == string2)
+    assert 'boxed_string_invocations:2 failed', (vbstring2.value == string2)
 
     # test invocation with value boxes
     p1 = VBstring.new('string1')
     p2 = VBstring.new('string2')
-    assert "boxed_string_invocations:3 failed", (p1.value == 'string1')
-    assert "boxed_string_invocations:3 failed", (p2.value == 'string2')
+    assert 'boxed_string_invocations:3 failed', (p1.value == 'string1')
+    assert 'boxed_string_invocations:3 failed', (p2.value == 'string2')
 
     p2_out = nil
     p3_out = nil
     retval = nil
     retval, p2_out, p3_out = test.string_op1(p1, p2)
 
-    assert "boxed_string_invocations:4 failed", (p2_out == '2string')
-    assert "boxed_string_invocations:4 failed", (p3_out == '2string')
-    assert "boxed_string_invocations:4 failed", (retval == '1string')
+    assert 'boxed_string_invocations:4 failed', (p2_out == '2string')
+    assert 'boxed_string_invocations:4 failed', (p3_out == '2string')
+    assert 'boxed_string_invocations:4 failed', (retval == '1string')
 
     # test invocation with Ruby types using valuebox values
-    assert "boxed_string_invocations:3 failed", (p1.value == 'string1')
-    assert "boxed_string_invocations:3 failed", (p2.value == 'string2')
+    assert 'boxed_string_invocations:3 failed', (p1.value == 'string1')
+    assert 'boxed_string_invocations:3 failed', (p2.value == 'string2')
 
     p2_out = nil
     p3_out = nil
     retval = nil
     retval, p2_out, p3_out = test.string_op2(p1.value, p2.value)
 
-    assert "boxed_string_invocations:4 failed", (p2_out == '2string')
-    assert "boxed_string_invocations:4 failed", (p3_out == '2string')
-    assert "boxed_string_invocations:4 failed", (retval == '1string')
+    assert 'boxed_string_invocations:4 failed', (p2_out == '2string')
+    assert 'boxed_string_invocations:4 failed', (p3_out == '2string')
+    assert 'boxed_string_invocations:4 failed', (retval == '1string')
   end
 
   def Test.boxed_sequence_invocations(test)
     # basic test
     p1 = VBseqlong.new([101, 202, 303])
-    assert "boxed_sequence_invocations:0 failed", (p1.value[0] == 101 && p1.value[2] == 303)
+    assert 'boxed_sequence_invocations:0 failed', (p1.value[0] == 101 && p1.value[2] == 303)
 
     # test invocation with value boxes
     p1 = VBseqlong.new([10, 9, 8, 7])
     p2 = VBseqlong.new([100, 99, 98])
-    assert "boxed_sequence_invocations:1 failed", (p1.value[0] == 10 && p1.value[3] == 7)
-    assert "boxed_sequence_invocations:1 failed", (p2.value[0] == 100 && p2.value[2] == 98)
+    assert 'boxed_sequence_invocations:1 failed', (p1.value[0] == 10 && p1.value[3] == 7)
+    assert 'boxed_sequence_invocations:1 failed', (p2.value[0] == 100 && p2.value[2] == 98)
 
     p2_out = nil
     p3_out = nil
@@ -190,13 +190,13 @@ module Test
     retval, p2_out, p3_out = test.seq_op1(p1, p2)
 
     p2.value().each_with_index do |e, i|
-      assert "boxed_sequence_invocations:2 failed", (p2_out[i] == e * 3)
+      assert 'boxed_sequence_invocations:2 failed', (p2_out[i] == e * 3)
     end
     p2.value().each_with_index do |e, i|
-      assert "boxed_sequence_invocations:2 failed", (p3_out[i] == e * 5)
+      assert 'boxed_sequence_invocations:2 failed', (p3_out[i] == e * 5)
     end
     p1.value().each_with_index do |e, i|
-      assert "boxed_sequence_invocations:2 failed", (retval[i] == e)
+      assert 'boxed_sequence_invocations:2 failed', (retval[i] == e)
     end
 
     # test invocation with Ruby types using valuebox values
@@ -205,10 +205,10 @@ module Test
     p2_out, p3_out = test.seq_op2(p1.value, p2.value)
 
     p2.value().each_with_index do |e, i|
-      assert "boxed_sequence_invocations:3 failed", (p2_out[i] == e * 3)
+      assert 'boxed_sequence_invocations:3 failed', (p2_out[i] == e * 3)
     end
     p2.value().each_with_index do |e, i|
-      assert "boxed_sequence_invocations:3 failed", (p3_out[i] == e * 5)
+      assert 'boxed_sequence_invocations:3 failed', (p3_out[i] == e * 5)
     end
   end
 
@@ -218,9 +218,9 @@ module Test
                 Fixed_Struct1.new(29,
                         Fixed_Struct1::Bstruct.new(117, 21)))
 
-    assert "boxed_struct_invocations:0 failed", (p1.value.is_a?(Fixed_Struct1))
-    assert "boxed_struct_invocations:0 failed", (p1.value.l == 29)
-    assert "boxed_struct_invocations:0 failed", (p1.value.abstruct.s1 == 117 && p1.value.abstruct.s2 == 21)
+    assert 'boxed_struct_invocations:0 failed', (p1.value.is_a?(Fixed_Struct1))
+    assert 'boxed_struct_invocations:0 failed', (p1.value.l == 29)
+    assert 'boxed_struct_invocations:0 failed', (p1.value.abstruct.s1 == 117 && p1.value.abstruct.s2 == 21)
 
     # test invocation with valueboxes
     p2 = VBfixed_struct1.new(
@@ -231,81 +231,81 @@ module Test
     retval = nil
     retval, p2_out, p3_out = test.struct_op1(p1, p2)
 
-    assert "boxed_struct_invocations:1 failed", (p2_out.is_a?(Fixed_Struct1))
-    assert "boxed_struct_invocations:1 failed", (p2_out.l == (92 * 3))
-    assert "boxed_struct_invocations:1 failed", (p2_out.abstruct.s1 == (171 * 3) &&
+    assert 'boxed_struct_invocations:1 failed', (p2_out.is_a?(Fixed_Struct1))
+    assert 'boxed_struct_invocations:1 failed', (p2_out.l == (92 * 3))
+    assert 'boxed_struct_invocations:1 failed', (p2_out.abstruct.s1 == (171 * 3) &&
                                                  p2_out.abstruct.s2 == (12 * 3))
 
-    assert "boxed_struct_invocations:1 failed", (p3_out.is_a?(Fixed_Struct1))
-    assert "boxed_struct_invocations:1 failed", (p3_out.l == (92 * 5))
-    assert "boxed_struct_invocations:1 failed", (p3_out.abstruct.s1 == (171 * 5) &&
+    assert 'boxed_struct_invocations:1 failed', (p3_out.is_a?(Fixed_Struct1))
+    assert 'boxed_struct_invocations:1 failed', (p3_out.l == (92 * 5))
+    assert 'boxed_struct_invocations:1 failed', (p3_out.abstruct.s1 == (171 * 5) &&
                                                  p3_out.abstruct.s2 == (12 * 5))
 
-    assert "boxed_struct_invocations:1 failed", (retval.is_a?(Fixed_Struct1))
-    assert "boxed_struct_invocations:1 failed", (retval.l == p1.value.l)
-    assert "boxed_struct_invocations:1 failed", (retval.abstruct.s1 == p1.value.abstruct.s1 &&
+    assert 'boxed_struct_invocations:1 failed', (retval.is_a?(Fixed_Struct1))
+    assert 'boxed_struct_invocations:1 failed', (retval.l == p1.value.l)
+    assert 'boxed_struct_invocations:1 failed', (retval.abstruct.s1 == p1.value.abstruct.s1 &&
                                                  retval.abstruct.s2 == p1.value.abstruct.s2)
 
     # test invocation with Ruby types using valuebox values
     p2_out, p3_out = test.struct_op2(p1.value, p2_out)
 
-    assert "boxed_struct_invocations:2 failed", (p2_out.is_a?(Fixed_Struct1))
-    assert "boxed_struct_invocations:2 failed", (p2_out.l == (92 * 3 * 3))
-    assert "boxed_struct_invocations:2 failed", (p2_out.abstruct.s1 == (171 * 3 * 3) &&
+    assert 'boxed_struct_invocations:2 failed', (p2_out.is_a?(Fixed_Struct1))
+    assert 'boxed_struct_invocations:2 failed', (p2_out.l == (92 * 3 * 3))
+    assert 'boxed_struct_invocations:2 failed', (p2_out.abstruct.s1 == (171 * 3 * 3) &&
                                                  p2_out.abstruct.s2 == (12 * 3 * 3))
 
-    assert "boxed_struct_invocations:2 failed", (p3_out.is_a?(Fixed_Struct1))
-    assert "boxed_struct_invocations:2 failed", (p3_out.l == p1.value.l)
-    assert "boxed_struct_invocations:2 failed", (p3_out.abstruct.s1 == p1.value.abstruct.s1 &&
+    assert 'boxed_struct_invocations:2 failed', (p3_out.is_a?(Fixed_Struct1))
+    assert 'boxed_struct_invocations:2 failed', (p3_out.l == p1.value.l)
+    assert 'boxed_struct_invocations:2 failed', (p3_out.abstruct.s1 == p1.value.abstruct.s1 &&
                                                  p3_out.abstruct.s2 == p1.value.abstruct.s2)
 
     # test invocation with valueboxes
     p1 = VBvariable_struct1.new(Variable_Struct1.new(29, 'variable1'))
     p2 = VBvariable_struct1.new(Variable_Struct1.new(37, 'variable2'))
 
-    assert "boxed_struct_invocations:3 failed", (p1.value.is_a?(Variable_Struct1))
-    assert "boxed_struct_invocations:3 failed", (p1.value.l == 29)
-    assert "boxed_struct_invocations:3 failed", (p1.value.str == 'variable1')
+    assert 'boxed_struct_invocations:3 failed', (p1.value.is_a?(Variable_Struct1))
+    assert 'boxed_struct_invocations:3 failed', (p1.value.l == 29)
+    assert 'boxed_struct_invocations:3 failed', (p1.value.str == 'variable1')
 
     p2_out = nil
     p3_out = nil
     retval = nil
     retval, p2_out, p3_out = test.struct_op3(p1, p2)
 
-    assert "boxed_struct_invocations:4 failed", (p2_out.is_a?(Variable_Struct1))
-    assert "boxed_struct_invocations:4 failed", (p2_out.l == (37 * 3))
-    assert "boxed_struct_invocations:4 failed", (p2_out.str == '2variable')
+    assert 'boxed_struct_invocations:4 failed', (p2_out.is_a?(Variable_Struct1))
+    assert 'boxed_struct_invocations:4 failed', (p2_out.l == (37 * 3))
+    assert 'boxed_struct_invocations:4 failed', (p2_out.str == '2variable')
 
-    assert "boxed_struct_invocations:4 failed", (p3_out.is_a?(Variable_Struct1))
-    assert "boxed_struct_invocations:4 failed", (p3_out.l == (37 * 3))
-    assert "boxed_struct_invocations:4 failed", (p3_out.str == '2variable')
+    assert 'boxed_struct_invocations:4 failed', (p3_out.is_a?(Variable_Struct1))
+    assert 'boxed_struct_invocations:4 failed', (p3_out.l == (37 * 3))
+    assert 'boxed_struct_invocations:4 failed', (p3_out.str == '2variable')
 
-    assert "boxed_struct_invocations:1 failed", (retval.is_a?(Variable_Struct1))
-    assert "boxed_struct_invocations:1 failed", (retval.l == p1.value.l)
-    assert "boxed_struct_invocations:1 failed", (retval.str == p1.value.str)
+    assert 'boxed_struct_invocations:1 failed', (retval.is_a?(Variable_Struct1))
+    assert 'boxed_struct_invocations:1 failed', (retval.l == p1.value.l)
+    assert 'boxed_struct_invocations:1 failed', (retval.str == p1.value.str)
 
     # test invocation with Ruby types using valuebox values
     p2_out, p3_out = test.struct_op4(p1.value, p2_out)
 
-    assert "boxed_struct_invocations:4 failed", (p2_out.is_a?(Variable_Struct1))
-    assert "boxed_struct_invocations:4 failed", (p2_out.l == (37 * 3 * 3))
-    assert "boxed_struct_invocations:4 failed", (p2_out.str == 'e2variabl')
+    assert 'boxed_struct_invocations:4 failed', (p2_out.is_a?(Variable_Struct1))
+    assert 'boxed_struct_invocations:4 failed', (p2_out.l == (37 * 3 * 3))
+    assert 'boxed_struct_invocations:4 failed', (p2_out.str == 'e2variabl')
 
-    assert "boxed_struct_invocations:1 failed", (p3_out.is_a?(Variable_Struct1))
-    assert "boxed_struct_invocations:1 failed", (p3_out.l == p1.value.l)
-    assert "boxed_struct_invocations:1 failed", (p3_out.str == p1.value.str)
+    assert 'boxed_struct_invocations:1 failed', (p3_out.is_a?(Variable_Struct1))
+    assert 'boxed_struct_invocations:1 failed', (p3_out.l == p1.value.l)
+    assert 'boxed_struct_invocations:1 failed', (p3_out.str == p1.value.str)
   end
 
   def Test.boxed_array_invocations(test)
     # basic test
     p1 = VBlongarray.new([101, 202, 303])
-    assert "boxed_array_invocations:0 failed", (p1.value[0] == 101 && p1.value[2] == 303)
+    assert 'boxed_array_invocations:0 failed', (p1.value[0] == 101 && p1.value[2] == 303)
 
     # test invocation with value boxes
     p1 = VBlongarray.new([10, 9, 8])
     p2 = VBlongarray.new([100, 99, 98])
-    assert "boxed_array_invocations:1 failed", (p1.value[0] == 10 && p1.value[2] == 8)
-    assert "boxed_array_invocations:1 failed", (p2.value[0] == 100 && p2.value[2] == 98)
+    assert 'boxed_array_invocations:1 failed', (p1.value[0] == 10 && p1.value[2] == 8)
+    assert 'boxed_array_invocations:1 failed', (p2.value[0] == 100 && p2.value[2] == 98)
 
     p2_out = nil
     p3_out = nil
@@ -313,13 +313,13 @@ module Test
     retval, p2_out, p3_out = test.array_op1(p1, p2)
 
     p2.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:2 failed", (p2_out[i] == e * 3)
+      assert 'boxed_array_invocations:2 failed', (p2_out[i] == e * 3)
     end
     p2.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:2 failed", (p3_out[i] == e * 3)
+      assert 'boxed_array_invocations:2 failed', (p3_out[i] == e * 3)
     end
     p1.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:2 failed", (retval[i] == e)
+      assert 'boxed_array_invocations:2 failed', (retval[i] == e)
     end
 
     # test invocation with Ruby types using valuebox values
@@ -328,17 +328,17 @@ module Test
     p2_out, p3_out = test.array_op2(p1.value, p2.value)
 
     p2.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:3 failed", (p2_out[i] == e * 3)
+      assert 'boxed_array_invocations:3 failed', (p2_out[i] == e * 3)
     end
     p1.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:3 failed", (p3_out[i] == e)
+      assert 'boxed_array_invocations:3 failed', (p3_out[i] == e)
     end
 
     # test invocation with value boxes
     p1 = VBstringarray.new(['in string1', 'in string1'])
     p2 = VBstringarray.new(['inout string1', 'inout string1'])
-    assert "boxed_array_invocations:4 failed", (p1.value[0] == 'in string1' && p1.value[1] == 'in string1')
-    assert "boxed_array_invocations:4 failed", (p2.value[0] == 'inout string1' && p2.value[1] == 'inout string1')
+    assert 'boxed_array_invocations:4 failed', (p1.value[0] == 'in string1' && p1.value[1] == 'in string1')
+    assert 'boxed_array_invocations:4 failed', (p2.value[0] == 'inout string1' && p2.value[1] == 'inout string1')
 
     p2_out = nil
     p3_out = nil
@@ -346,13 +346,13 @@ module Test
     retval, p2_out, p3_out = test.array_op3(p1, p2)
 
     p2.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:5 failed", (p2_out[i] == '1inout string')
+      assert 'boxed_array_invocations:5 failed', (p2_out[i] == '1inout string')
     end
     p2.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:5 failed", (p3_out[i] == '1inout string')
+      assert 'boxed_array_invocations:5 failed', (p3_out[i] == '1inout string')
     end
     p1.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:5 failed", (retval[i] == e)
+      assert 'boxed_array_invocations:5 failed', (retval[i] == e)
     end
 
     # test invocation with Ruby types using valuebox values
@@ -361,12 +361,13 @@ module Test
     p2_out, p3_out = test.array_op4(p1.value, p2.value)
 
     p2.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:6 failed", (p2_out[i] == '1inout string')
+      assert 'boxed_array_invocations:6 failed', (p2_out[i] == '1inout string')
     end
     p1.value().each_with_index do |e, i|
-      assert "boxed_array_invocations:6 failed", (p3_out[i] == e)
+      assert 'boxed_array_invocations:6 failed', (p3_out[i] == e)
     end
   end
+
   def Test.boxed_union_invocations(test)
     # basic test
     p1 = VBfixed_union1.new(Fixed_Union1.new)
@@ -374,13 +375,13 @@ module Test
     p2 = VBfixed_union1.new(Fixed_Union1.new)
     p2.value.m2 = 789
 
-    assert "boxed_union_invocations:0 failed", (p1.value.is_a?(Fixed_Union1))
-    assert "boxed_union_invocations:0 failed", (p1.value._disc == 1)
-    assert "boxed_union_invocations:0 failed", (p1.value.m1 == 321)
+    assert 'boxed_union_invocations:0 failed', (p1.value.is_a?(Fixed_Union1))
+    assert 'boxed_union_invocations:0 failed', (p1.value._disc == 1)
+    assert 'boxed_union_invocations:0 failed', (p1.value.m1 == 321)
 
-    assert "boxed_union_invocations:0 failed", (p2.value.is_a?(Fixed_Union1))
-    assert "boxed_union_invocations:0 failed", (p2.value._disc == 2)
-    assert "boxed_union_invocations:0 failed", (p2.value.m1 == 789)
+    assert 'boxed_union_invocations:0 failed', (p2.value.is_a?(Fixed_Union1))
+    assert 'boxed_union_invocations:0 failed', (p2.value._disc == 2)
+    assert 'boxed_union_invocations:0 failed', (p2.value.m1 == 789)
 
     # test invocation with valueboxes
     p2_out = nil
@@ -388,30 +389,30 @@ module Test
     retval = nil
     retval, p2_out, p3_out = test.union_op1(p1, p2)
 
-    assert "boxed_union_invocations:1 failed", (p2_out.is_a?(Fixed_Union1))
-    assert "boxed_union_invocations:1 failed", (p2_out._disc == 2)
-    assert "boxed_union_invocations:1 failed", (p2_out.m2 == 789 * 3)
+    assert 'boxed_union_invocations:1 failed', (p2_out.is_a?(Fixed_Union1))
+    assert 'boxed_union_invocations:1 failed', (p2_out._disc == 2)
+    assert 'boxed_union_invocations:1 failed', (p2_out.m2 == 789 * 3)
 
-    assert "boxed_union_invocations:1 failed", (p3_out.is_a?(Fixed_Union1))
-    assert "boxed_union_invocations:1 failed", (p3_out._disc == 1)
-    assert "boxed_union_invocations:1 failed", (p3_out.m1 == 321 * 3)
+    assert 'boxed_union_invocations:1 failed', (p3_out.is_a?(Fixed_Union1))
+    assert 'boxed_union_invocations:1 failed', (p3_out._disc == 1)
+    assert 'boxed_union_invocations:1 failed', (p3_out.m1 == 321 * 3)
 
-    assert "boxed_union_invocations:1 failed", (retval.is_a?(Fixed_Union1))
-    assert "boxed_union_invocations:1 failed", (retval._disc == 1)
-    assert "boxed_union_invocations:1 failed", (retval.m1 == 321 * 3)
+    assert 'boxed_union_invocations:1 failed', (retval.is_a?(Fixed_Union1))
+    assert 'boxed_union_invocations:1 failed', (retval._disc == 1)
+    assert 'boxed_union_invocations:1 failed', (retval.m1 == 321 * 3)
 
     # test invocation with Ruby types using valuebox values
     p2_out = nil
     p3_out = nil
     p2_out, p3_out = test.union_op2(p1.value, p2.value)
 
-    assert "boxed_union_invocations:1 failed", (p2_out.is_a?(Fixed_Union1))
-    assert "boxed_union_invocations:1 failed", (p2_out._disc == 2)
-    assert "boxed_union_invocations:1 failed", (p2_out.m2 == 789 * 3)
+    assert 'boxed_union_invocations:1 failed', (p2_out.is_a?(Fixed_Union1))
+    assert 'boxed_union_invocations:1 failed', (p2_out._disc == 2)
+    assert 'boxed_union_invocations:1 failed', (p2_out.m2 == 789 * 3)
 
-    assert "boxed_union_invocations:1 failed", (p3_out.is_a?(Fixed_Union1))
-    assert "boxed_union_invocations:1 failed", (p3_out._disc == 1)
-    assert "boxed_union_invocations:1 failed", (p3_out.m1 == 321)
+    assert 'boxed_union_invocations:1 failed', (p3_out.is_a?(Fixed_Union1))
+    assert 'boxed_union_invocations:1 failed', (p3_out._disc == 1)
+    assert 'boxed_union_invocations:1 failed', (p3_out.m1 == 321)
 
     # test invocation with valueboxes
     p1 = VBvariable_union1.new(Variable_Union1.new)
@@ -419,50 +420,50 @@ module Test
     p2 = VBvariable_union1.new(Variable_Union1.new)
     p2.value.m2 = 'abracadabra'
 
-    assert "boxed_union_invocations:0 failed", (p1.value.is_a?(Variable_Union1))
-    assert "boxed_union_invocations:0 failed", (p1.value._disc == 1)
-    assert "boxed_union_invocations:0 failed", (p1.value.m1 == 321)
+    assert 'boxed_union_invocations:0 failed', (p1.value.is_a?(Variable_Union1))
+    assert 'boxed_union_invocations:0 failed', (p1.value._disc == 1)
+    assert 'boxed_union_invocations:0 failed', (p1.value.m1 == 321)
 
-    assert "boxed_union_invocations:0 failed", (p2.value.is_a?(Variable_Union1))
-    assert "boxed_union_invocations:0 failed", (p2.value._disc == 2)
-    assert "boxed_union_invocations:0 failed", (p2.value.m1 == 'abracadabra')
+    assert 'boxed_union_invocations:0 failed', (p2.value.is_a?(Variable_Union1))
+    assert 'boxed_union_invocations:0 failed', (p2.value._disc == 2)
+    assert 'boxed_union_invocations:0 failed', (p2.value.m1 == 'abracadabra')
 
     p2_out = nil
     p3_out = nil
     retval = nil
     retval, p2_out, p3_out = test.union_op3(p1, p2)
 
-    assert "boxed_union_invocations:1 failed", (p2_out.is_a?(Variable_Union1))
-    assert "boxed_union_invocations:1 failed", (p2_out._disc == 2)
-    assert "boxed_union_invocations:1 failed", (p2_out.m2 == 'aabracadabr')
+    assert 'boxed_union_invocations:1 failed', (p2_out.is_a?(Variable_Union1))
+    assert 'boxed_union_invocations:1 failed', (p2_out._disc == 2)
+    assert 'boxed_union_invocations:1 failed', (p2_out.m2 == 'aabracadabr')
 
-    assert "boxed_union_invocations:1 failed", (p3_out.is_a?(Variable_Union1))
-    assert "boxed_union_invocations:1 failed", (p3_out._disc == 1)
-    assert "boxed_union_invocations:1 failed", (p3_out.m1 == 321)
+    assert 'boxed_union_invocations:1 failed', (p3_out.is_a?(Variable_Union1))
+    assert 'boxed_union_invocations:1 failed', (p3_out._disc == 1)
+    assert 'boxed_union_invocations:1 failed', (p3_out.m1 == 321)
 
-    assert "boxed_union_invocations:1 failed", (retval.is_a?(Variable_Union1))
-    assert "boxed_union_invocations:1 failed", (retval._disc == 1)
-    assert "boxed_union_invocations:1 failed", (retval.m1 == 321)
+    assert 'boxed_union_invocations:1 failed', (retval.is_a?(Variable_Union1))
+    assert 'boxed_union_invocations:1 failed', (retval._disc == 1)
+    assert 'boxed_union_invocations:1 failed', (retval.m1 == 321)
 
     # test invocation with Ruby types using valuebox values
     p2_out = nil
     p3_out = nil
     p2_out, p3_out = test.union_op4(p1.value, p2.value)
 
-    assert "boxed_union_invocations:1 failed", (p2_out.is_a?(Variable_Union1))
-    assert "boxed_union_invocations:1 failed", (p2_out._disc == 2)
-    assert "boxed_union_invocations:1 failed", (p2_out.m2 == 'aabracadabr')
+    assert 'boxed_union_invocations:1 failed', (p2_out.is_a?(Variable_Union1))
+    assert 'boxed_union_invocations:1 failed', (p2_out._disc == 2)
+    assert 'boxed_union_invocations:1 failed', (p2_out.m2 == 'aabracadabr')
 
-    assert "boxed_union_invocations:1 failed", (p3_out.is_a?(Variable_Union1))
-    assert "boxed_union_invocations:1 failed", (p3_out._disc == 1)
-    assert "boxed_union_invocations:1 failed", (p3_out.m1 == 321)
+    assert 'boxed_union_invocations:1 failed', (p3_out.is_a?(Variable_Union1))
+    assert 'boxed_union_invocations:1 failed', (p3_out._disc == 1)
+    assert 'boxed_union_invocations:1 failed', (p3_out.m1 == 321)
 
   end
 end
 
 ##
 
-orb = CORBA.ORB_init(["-ORBDebugLevel", OPTIONS[:orb_debuglevel]], 'myORB')
+orb = CORBA.ORB_init(['-ORBDebugLevel', OPTIONS[:orb_debuglevel]], 'myORB')
 
 begin
   obj = orb.string_to_object(OPTIONS[:iorfile])