Arrow::TestCase

Test case class

Constants

AnsiAttributes: Set some ANSI escape code constants (Shamelessly stolen from Perl‘s Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
ConfigSaveFile: The name of the file containing marshalled configuration values

Attributes

setupMethods[RW]

(Not documented)

teardownMethods[RW]

(Not documented)

Public Class Methods

addSetupBlock( &block ) click to toggle source

Append a setup block for the current testcase

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 153
153:     def self::addSetupBlock( &block )
154:         @@methodCounter += 1
155:         newMethodName = "setup_#{@@methodCounter}".intern
156:         define_method( newMethodName, &block )
157:         self.setupMethods.push newMethodName
158:     end

addTeardownBlock( &block ) click to toggle source

Prepend a teardown block for the current testcase

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 162
162:     def self::addTeardownBlock( &block )
163:         @@methodCounter += 1
164:         newMethodName = "teardown_#{@@methodCounter}".intern
165:         define_method( newMethodName, &block )
166:         self.teardownMethods.unshift newMethodName
167:     end

ansiCode( *attributes ) click to toggle source

Returns a String containing the specified ANSI escapes suitable for inclusion in another string. The attributes should be one or more of the keys of AnsiAttributes.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 122
122:     def self::ansiCode( *attributes )
123:         return '' unless /(?:xterm(?:-color)?|eterm|linux)/i =~ ENV['TERM']
124: 
125:         attr = attributes.collect {|a|
126:             AnsiAttributes[a] ? AnsiAttributes[a] : nil
127:         }.compact.join(';')
128:         if attr.empty? 
129:             return ''
130:         else
131:             return "\e[%sm" % attr
132:         end
133:     end

debugMsg( *msgs ) click to toggle source

Output the specified msgs joined together to STDERR if $DEBUG is set.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 138
138:     def self::debugMsg( *msgs )
139:         return unless $DEBUG
140:         self.message "%sDEBUG>>> %s %s" %
141:             [ ansiCode('dark', 'white'), msgs.join(''), ansiCode('reset') ]
142:     end

inherited( klass ) click to toggle source

Inheritance callback — adds @setupMethods and @teardownMethods ivars and accessors to the inheriting class.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 106
106:     def self::inherited( klass )
107:         klass.module_eval {
108:             @setupMethods = []
109:             @teardownMethods = []
110: 
111:             class << self
112:                 attr_accessor :setupMethods
113:                 attr_accessor :teardownMethods
114:             end
115:         }
116:     end

message( *msgs ) click to toggle source

Output the specified msgs joined together to STDOUT.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 147
147:     def self::message( *msgs )
148:         $stderr.puts msgs.join('')
149:         $stderr.flush
150:     end

Public Instance Methods

addSetupBlock( &block ) click to toggle source

Add the specified block to the code that gets executed by #setup.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 219
219:     def addSetupBlock( &block ); self.class.addSetupBlock( &block ); end

addTeardownBlock( &block ) click to toggle source

Add the specified block to the code that gets executed by #teardown.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 223
223:     def addTeardownBlock( &block ); self.class.addTeardownBlock( &block ); end

ansiCode( *attributes ) click to toggle source

Instance-alias for the like-named class method

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 461
461:     def ansiCode( *attributes )
462:         self.class.ansiCode( *attributes )
463:     end

assert_has_instance_method( klass, meth ) click to toggle source

Assert that the specified klass defines the specified instance method meth.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 434
434:     def assert_has_instance_method( klass, meth )
435:         msg = "<%s> expected to define instance method #%s" %
436:             [ klass, meth ]
437:         assert_block( msg ) {
438:             klass.instance_methods.include?( meth.to_s )
439:         }
440:     rescue Test::Unit::AssertionFailedError => err
441:         cutframe = err.backtrace.reverse.find {|frame|
442:             /assert_has_instance_method/ =~ frame
443:         }
444:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
445:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
446:     end

assert_has_ivar( sym, object ) click to toggle source

Assert that the specified object has an instance variable which matches the specified sym. The ’@’ at the beginning of the sym will be prepended if not present.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 399
399:     def assert_has_ivar( sym, object )
400:         sym = "@#{sym}" unless /^@/ =~ sym.to_s
401:         msg = "Object <%s> expected to have an instance variable <%s>" %
402:             [ object.inspect, sym ]
403:         assert_block( msg ) {
404:             object.instance_variables.include?( sym.to_s )
405:         }
406:     rescue Test::Unit::AssertionFailedError => err
407:         cutframe = err.backtrace.reverse.find {|frame|
408:             /assert_has_ivar/ =~ frame
409:         }
410:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
411:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
412:     end

assert_hash_equal( expected, actual, msg="" ) click to toggle source

Test Hashes for equivalent content

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 234
234:     def assert_hash_equal( expected, actual, msg="" )
235:         errmsg = "Expected hash <%p> to be equal to <%p>" % [expected, actual]
236:         errmsg += ": #{msg}" unless msg.empty?
237: 
238:         assert_block( errmsg ) {
239:             diffs = compare_hashes( expected, actual )
240:             unless diffs.empty?
241:                 errmsg += ": " + diffs.join("; ")
242:                 return false
243:             else
244:                 return true
245:             end
246:         }
247:     rescue Test::Unit::AssertionFailedError => err
248:         cutframe = err.backtrace.reverse.find {|frame|
249:             /assert_hash_equal/ =~ frame
250:         }
251:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
252:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
253:     end

assert_include( item, obj, msg=nil ) click to toggle source

Succeeds if obj include? item.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 333
333:     def assert_include( item, obj, msg=nil )
334:         msg ||= "<%p> expected to include <%p>." % [ obj, item ]
335:         assert_block( msg ) { obj.respond_to?(:include?) && obj.include?(item) }
336:     rescue Test::Unit::AssertionFailedError => err
337:         cutframe = err.backtrace.reverse.find {|frame|
338:             /assert_include/ =~ frame
339:         }
340:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
341:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
342:     end

assert_ivar_equal( value, object, sym ) click to toggle source

Assert that the instance variable specified by sym of an object is equal to the specified value. The ’@’ at the beginning of the sym will be prepended if not present.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 379
379:     def assert_ivar_equal( value, object, sym )
380:         sym = "@#{sym}".intern unless /^@/ =~ sym.to_s
381:         msg = "Instance variable '%s'\n\tof <%s>\n\texpected to be <%s>\n" %
382:             [ sym, object.inspect, value.inspect ]
383:         msg += "\tbut was: <%p>" % [ object.instance_variable_get(sym) ]
384:         assert_block( msg ) {
385:             value == object.instance_variable_get(sym)
386:         }
387:     rescue Test::Unit::AssertionFailedError => err
388:         cutframe = err.backtrace.reverse.find {|frame|
389:             /assert_ivar_equal/ =~ frame
390:         }
391:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
392:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
393:     end

assert_not_match( re, str ) click to toggle source

Assert that the specified str does not match the given regular expression re.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 417
417:     def assert_not_match( re, str )
418:         msg = "<%s> expected not to match %p" %
419:             [ str, re ]
420:         assert_block( msg ) {
421:             !re.match( str )
422:         }
423:     rescue Test::Unit::AssertionFailedError => err
424:         cutframe = err.backtrace.reverse.find {|frame|
425:             /assert_not_match/ =~ frame
426:         }
427:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
428:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
429:     end

assert_not_nil( obj, msg=nil ) click to toggle source

Override the stupid deprecated #assert_not_nil so when it disappears, code doesn‘t break.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 320
320:     def assert_not_nil( obj, msg=nil )
321:         msg ||= "<%p> expected to not be nil." % obj
322:         assert_block( msg ) { !obj.nil? }
323:     rescue Test::Unit::AssertionFailedError => err
324:         cutframe = err.backtrace.reverse.find {|frame|
325:             /assert_not_nil/ =~ frame
326:         }
327:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
328:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
329:     end

assert_not_respond_to( obj, meth ) click to toggle source

Negative of assert_respond_to

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 361
361:     def assert_not_respond_to( obj, meth )
362:         msg = "%s expected NOT to respond to '%s'" %
363:             [ obj.inspect, meth ]
364:         assert_block( msg ) {
365:             !obj.respond_to?( meth )
366:         }
367:     rescue Test::Unit::AssertionFailedError => err
368:         cutframe = err.backtrace.reverse.find {|frame|
369:             /assert_not_respond_to/ =~ frame
370:         }
371:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
372:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
373:     end

assert_not_tainted( obj, msg=nil ) click to toggle source

Negative of assert_respond_to

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 346
346:     def assert_not_tainted( obj, msg=nil )
347:         msg ||= "<%p> expected to NOT be tainted" % [ obj ]
348:         assert_block( msg ) {
349:             !obj.tainted?
350:         }
351:     rescue Test::Unit::AssertionFailedError => err
352:         cutframe = err.backtrace.reverse.find {|frame|
353:             /assert_not_tainted/ =~ frame
354:         }
355:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
356:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
357:     end

assert_same_keys( expected, actual, msg="" ) click to toggle source

Test Hashes (or any other objects with a #keys method) for key set equality

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 284
284:     def assert_same_keys( expected, actual, msg="" )
285:         errmsg = "Expected keys of <%p> to be equal to those of <%p>" %
286:             [ actual, expected ]
287:         errmsg += ": #{msg}" unless msg.empty?
288: 
289:         ekeys = expected.keys; akeys = actual.keys
290:         assert_block( errmsg ) {
291:             diffs = []
292: 
293:             # XOR the arrays and make a diff for each one
294:             ((ekeys + akeys) - (ekeys & akeys)).each do |key|
295:                 if ekeys.include?( key )
296:                     diffs << "missing key %p" % [key]
297:                 else
298:                     diffs << "extra key %p" % [key]
299:                 end
300:             end
301: 
302:             unless diffs.empty?
303:                 errmsg += "\n" + diffs.join("; ")
304:                 return false
305:             else
306:                 return true
307:             end
308:         }
309:     rescue Test::Unit::AssertionFailedError => err
310:         cutframe = err.backtrace.reverse.find {|frame|
311:             /assert_hash_equal/ =~ frame
312:         }
313:         firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
314:         Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
315:     end

collectGarbage() click to toggle source

Try to force garbage collection to start.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 502
502:     def collectGarbage
503:         a = []
504:         1000.times { a << {} }
505:         a = nil
506:         GC.start
507:     end

compare_hashes( hash1, hash2, subkeys=nil ) click to toggle source

Compare two hashes for content, returning a list of their differences as descriptions. An empty Array return-value means they were the same.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 258
258:     def compare_hashes( hash1, hash2, subkeys=nil )
259:         diffs = []
260:         seenKeys = []
261: 
262:         hash1.each {|k,v|
263:             if !hash2.key?( k )
264:                 diffs << "missing %p pair" % k
265:             elsif hash1[k].is_a?( Hash ) && hash2[k].is_a?( Hash )
266:                 diffs.push( compare_hashes(hash1[k], hash2[k]) )
267:             elsif hash2[k] != hash1[k]
268:                 diffs << "value for %p expected to be %p, but was %p" %
269:                     [ k, hash1[k], hash2[k] ]
270:             else
271:                 seenKeys << k
272:             end
273:         }
274: 
275:         extraKeys = (hash2.keys - hash1.keys)
276:         diffs << "extra key/s: #{extraKeys.join(', ')}" unless extraKeys.empty?
277: 
278:         return diffs.flatten
279:     end

debugMsg( *msgs ) click to toggle source

Instance alias for the like-named class method

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 467
467:     def debugMsg( *msgs )
468:         self.class.debugMsg( *msgs )
469:     end

default_test() click to toggle source

Turn off the stupid ‘No tests were specified‘

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 227
227:     def default_test; end

hrule( length=75, char="-" ) click to toggle source

Return a separator line made up of length of the specified char.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 474
474:     def hrule( length=75, char="-" )
475:         return (char * length ) + "\n"
476:     end

hruleSection( content, caption='' ) click to toggle source

Return a section delimited by hrules with the specified caption and content.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 480
480:     def hruleSection( content, caption='' )
481:         caption << ' ' unless caption.empty?
482:         return caption +
483:             hrule( 75 - caption.length ) +
484:             content.chomp + "\n" +
485:             hrule()
486:     end

message( *msgs ) click to toggle source

Instance alias for the like-named class method.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 455
455:     def message( *msgs )
456:         self.class.message( *msgs )
457:     end

printTestHeader( desc ) click to toggle source

Output a header for delimiting tests

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 490
490:     def printTestHeader( desc )
491:         return unless $VERBOSE || $DEBUG
492:         message "%s>>> %s <<<%s" % 
493:             [ ansiCode('bold','yellow','on_blue'), desc, ansiCode('reset') ]
494:     end

prompt( promptString ) click to toggle source

Output the specified promptString as a prompt (in green) and return the user‘s input with leading and trailing spaces removed.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 547
547:     def prompt( promptString )
548:         promptString.chomp!
549:         return readline( ansiCode('bold', 'green') + "#{promptString}: " +
550:                          ansiCode('reset') ).strip
551:     end

promptWithDefault( promptString, default ) click to toggle source

Prompt the user with the given promptString via #prompt, substituting the given default if the user doesn‘t input anything.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 557
557:     def promptWithDefault( promptString, default )
558:         response = prompt( "%s [%s]" % [ promptString, default ] )
559:         if response.empty?
560:             return default
561:         else
562:             return response
563:         end
564:     end

run( result ) click to toggle source

Output the name of the test as it‘s running if in verbose mode.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 518
518:     def run( result )
519:         $stderr.puts self.name if $VERBOSE || $DEBUG
520: 
521:         # Support debugging for individual tests
522:         olddb = nil
523:         if $DebugPattern && $DebugPattern =~ @method_name
524:             Arrow::Logger.global.outputters <<
525:                 Arrow::Logger::Outputter.create( 'file:stderr' )
526:             Arrow::Logger.global.level = :debug
527: 
528:             olddb = $DEBUG
529:             $DEBUG = true
530:         end
531:         
532:         super
533: 
534:         unless olddb.nil?
535:             $DEBUG = olddb 
536:             Arrow::Logger.global.outputters.clear
537:         end
538:     end

set_up( *args ) click to toggle source

Alias for #setup

setup( *args ) click to toggle source

Run dynamically-added setup methods

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 180
180:     def setup( *args )
181:         if self.class < Arrow::TestCase
182:             self.class.setupMethods.each {|sblock|
183:                 self.send( sblock )
184:             }
185:         end
186:     end

Also aliased as: set_up

skip( reason=nil ) click to toggle source

Skip the current step (called from #setup) with the reason given.

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 202
202:     def skip( reason=nil )
203:         if reason
204:             msg = "Skipping %s: %s" % [ @method_name, reason ]
205:         else
206:             msg = "Skipping %s: No reason given." % @method_name
207:         end
208: 
209:         $stderr.puts( msg ) if $VERBOSE
210:         @method_name = :skipped_test
211:     end

tear_down( *args ) click to toggle source

Alias for #teardown

teardown( *args ) click to toggle source

Run dynamically-added teardown methods

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 191
191:     def teardown( *args )
192:         if self.class < Arrow::TestCase
193:             self.class.teardownMethods.each {|tblock|
194:                 self.send( tblock )
195:             }
196:         end
197:     end

Also aliased as: tear_down

zerofile( filename ) click to toggle source

Touch a file and truncate it to 0 bytes

     # File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 511
511:     def zerofile( filename )
512:         File.open( filename, File::WRONLY|File::CREAT ) {}
513:         File.truncate( filename, 0 )
514:     end

secsequence

--- SEC00182

seccomment

--- ""

attributes

--- 
- name: setupMethods
  rw: RW
  a_desc: ""
- name: teardownMethods
  rw: RW
  a_desc: ""

method_list

--- 
- methods: 
  - visibility: public
    aref: M000244
    name: addSetupBlock
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 153</span>\n\
      153:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">addSetupBlock</span>( <span class=\"ruby-operator\">&amp;</span><span class=\"ruby-identifier\">block</span> )\n\
      154:         <span class=\"ruby-ivar\">@@methodCounter</span> <span class=\"ruby-operator\">+=</span> <span class=\"ruby-value\">1</span>\n\
      155:         <span class=\"ruby-identifier\">newMethodName</span> = <span class=\"ruby-node\">&quot;setup_#{@@methodCounter}&quot;</span>.<span class=\"ruby-identifier\">intern</span>\n\
      156:         <span class=\"ruby-identifier\">define_method</span>( <span class=\"ruby-identifier\">newMethodName</span>, <span class=\"ruby-operator\">&amp;</span><span class=\"ruby-identifier\">block</span> )\n\
      157:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">setupMethods</span>.<span class=\"ruby-identifier\">push</span> <span class=\"ruby-identifier\">newMethodName</span>\n\
      158:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Append a <a href="TestCase.html#M000246">setup</a> block for the current
      testcase
      </p>
    params: ( &amp;block )
  - visibility: public
    aref: M000245
    name: addTeardownBlock
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 162</span>\n\
      162:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">addTeardownBlock</span>( <span class=\"ruby-operator\">&amp;</span><span class=\"ruby-identifier\">block</span> )\n\
      163:         <span class=\"ruby-ivar\">@@methodCounter</span> <span class=\"ruby-operator\">+=</span> <span class=\"ruby-value\">1</span>\n\
      164:         <span class=\"ruby-identifier\">newMethodName</span> = <span class=\"ruby-node\">&quot;teardown_#{@@methodCounter}&quot;</span>.<span class=\"ruby-identifier\">intern</span>\n\
      165:         <span class=\"ruby-identifier\">define_method</span>( <span class=\"ruby-identifier\">newMethodName</span>, <span class=\"ruby-operator\">&amp;</span><span class=\"ruby-identifier\">block</span> )\n\
      166:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">teardownMethods</span>.<span class=\"ruby-identifier\">unshift</span> <span class=\"ruby-identifier\">newMethodName</span>\n\
      167:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Prepend a <a href="TestCase.html#M000248">teardown</a> block for the
      current testcase
      </p>
    params: ( &amp;block )
  - visibility: public
    aref: M000241
    name: ansiCode
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 122</span>\n\
      122:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">ansiCode</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">attributes</span> )\n\
      123:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-value str\">''</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-regexp re\">/(?:xterm(?:-color)?|eterm|linux)/i</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-constant\">ENV</span>[<span class=\"ruby-value str\">'TERM'</span>]\n\
      124: \n\
      125:         <span class=\"ruby-identifier\">attr</span> = <span class=\"ruby-identifier\">attributes</span>.<span class=\"ruby-identifier\">collect</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">a</span><span class=\"ruby-operator\">|</span>\n\
      126:             <span class=\"ruby-constant\">AnsiAttributes</span>[<span class=\"ruby-identifier\">a</span>] <span class=\"ruby-operator\">?</span> <span class=\"ruby-constant\">AnsiAttributes</span>[<span class=\"ruby-identifier\">a</span>] <span class=\"ruby-operator\">:</span> <span class=\"ruby-keyword kw\">nil</span>\n\
      127:         }.<span class=\"ruby-identifier\">compact</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">';'</span>)\n\
      128:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">attr</span>.<span class=\"ruby-identifier\">empty?</span> \n\
      129:             <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-value str\">''</span>\n\
      130:         <span class=\"ruby-keyword kw\">else</span>\n\
      131:             <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-value str\">&quot;\\e[%sm&quot;</span> <span class=\"ruby-operator\">%</span> <span class=\"ruby-identifier\">attr</span>\n\
      132:         <span class=\"ruby-keyword kw\">end</span>\n\
      133:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Returns a String containing the specified ANSI escapes suitable for
      inclusion in another string. The <tt>attributes</tt> should be one or more
      of the keys of AnsiAttributes.
      </p>
    params: ( *attributes )
  - visibility: public
    aref: M000242
    name: debugMsg
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 138</span>\n\
      138:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">debugMsg</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">msgs</span> )\n\
      139:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">$DEBUG</span>\n\
      140:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">message</span> <span class=\"ruby-value str\">&quot;%sDEBUG&gt;&gt;&gt; %s %s&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      141:             [ <span class=\"ruby-identifier\">ansiCode</span>(<span class=\"ruby-value str\">'dark'</span>, <span class=\"ruby-value str\">'white'</span>), <span class=\"ruby-identifier\">msgs</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">''</span>), <span class=\"ruby-identifier\">ansiCode</span>(<span class=\"ruby-value str\">'reset'</span>) ]\n\
      142:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Output the specified <tt>msgs</tt> joined together to <tt>STDERR</tt> if
      <tt>$DEBUG</tt> is set.
      </p>
    params: ( *msgs )
  - visibility: public
    aref: M000240
    name: inherited
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 106</span>\n\
      106:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">inherited</span>( <span class=\"ruby-identifier\">klass</span> )\n\
      107:         <span class=\"ruby-identifier\">klass</span>.<span class=\"ruby-identifier\">module_eval</span> {\n\
      108:             <span class=\"ruby-ivar\">@setupMethods</span> = []\n\
      109:             <span class=\"ruby-ivar\">@teardownMethods</span> = []\n\
      110: \n\
      111:             <span class=\"ruby-keyword kw\">class</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-keyword kw\">self</span>\n\
      112:                 <span class=\"ruby-identifier\">attr_accessor</span> <span class=\"ruby-identifier\">:setupMethods</span>\n\
      113:                 <span class=\"ruby-identifier\">attr_accessor</span> <span class=\"ruby-identifier\">:teardownMethods</span>\n\
      114:             <span class=\"ruby-keyword kw\">end</span>\n\
      115:         }\n\
      116:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Inheritance callback &#8212; adds @setupMethods and @teardownMethods ivars
      and accessors to the inheriting class.
      </p>
    params: ( klass )
  - visibility: public
    aref: M000243
    name: message
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 147</span>\n\
      147:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">message</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">msgs</span> )\n\
      148:         <span class=\"ruby-identifier\">$stderr</span>.<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-identifier\">msgs</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">''</span>)\n\
      149:         <span class=\"ruby-identifier\">$stderr</span>.<span class=\"ruby-identifier\">flush</span>\n\
      150:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Output the specified <tt>msgs</tt> joined together to <tt>STDOUT</tt>.
      </p>
    params: ( *msgs )
  category: Class
  type: Public
- methods: 
  - visibility: public
    aref: M000251
    name: addSetupBlock
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 219</span>\n\
      219:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">addSetupBlock</span>( <span class=\"ruby-operator\">&amp;</span><span class=\"ruby-identifier\">block</span> ); <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">addSetupBlock</span>( <span class=\"ruby-operator\">&amp;</span><span class=\"ruby-identifier\">block</span> ); <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Add the specified <tt>block</tt> to the code that gets executed by <a
      href="TestCase.html#M000246">#setup</a>.
      </p>
    params: ( &amp;block )
  - visibility: public
    aref: M000252
    name: addTeardownBlock
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 223</span>\n\
      223:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">addTeardownBlock</span>( <span class=\"ruby-operator\">&amp;</span><span class=\"ruby-identifier\">block</span> ); <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">addTeardownBlock</span>( <span class=\"ruby-operator\">&amp;</span><span class=\"ruby-identifier\">block</span> ); <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Add the specified <tt>block</tt> to the code that gets executed by <a
      href="TestCase.html#M000248">#teardown</a>.
      </p>
    params: ( &amp;block )
  - visibility: public
    aref: M000266
    name: ansiCode
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 461</span>\n\
      461:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">ansiCode</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">attributes</span> )\n\
      462:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">ansiCode</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">attributes</span> )\n\
      463:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Instance-alias for the like-named class method
      </p>
    params: ( *attributes )
  - visibility: public
    aref: M000264
    name: assert_has_instance_method
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 434</span>\n\
      434:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_has_instance_method</span>( <span class=\"ruby-identifier\">klass</span>, <span class=\"ruby-identifier\">meth</span> )\n\
      435:         <span class=\"ruby-identifier\">msg</span> = <span class=\"ruby-value str\">&quot;&lt;%s&gt; expected to define instance method #%s&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      436:             [ <span class=\"ruby-identifier\">klass</span>, <span class=\"ruby-identifier\">meth</span> ]\n\
      437:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">msg</span> ) {\n\
      438:             <span class=\"ruby-identifier\">klass</span>.<span class=\"ruby-identifier\">instance_methods</span>.<span class=\"ruby-identifier\">include?</span>( <span class=\"ruby-identifier\">meth</span>.<span class=\"ruby-identifier\">to_s</span> )\n\
      439:         }\n\
      440:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      441:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      442:             <span class=\"ruby-regexp re\">/assert_has_instance_method/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      443:         }\n\
      444:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      445:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      446:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Assert that the specified <tt>klass</tt> defines the specified instance
      method <tt>meth</tt>.
      </p>
    params: ( klass, meth )
  - visibility: public
    aref: M000262
    name: assert_has_ivar
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 399</span>\n\
      399:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_has_ivar</span>( <span class=\"ruby-identifier\">sym</span>, <span class=\"ruby-identifier\">object</span> )\n\
      400:         <span class=\"ruby-identifier\">sym</span> = <span class=\"ruby-node\">&quot;@#{sym}&quot;</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-regexp re\">/^@/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">sym</span>.<span class=\"ruby-identifier\">to_s</span>\n\
      401:         <span class=\"ruby-identifier\">msg</span> = <span class=\"ruby-value str\">&quot;Object &lt;%s&gt; expected to have an instance variable &lt;%s&gt;&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      402:             [ <span class=\"ruby-identifier\">object</span>.<span class=\"ruby-identifier\">inspect</span>, <span class=\"ruby-identifier\">sym</span> ]\n\
      403:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">msg</span> ) {\n\
      404:             <span class=\"ruby-identifier\">object</span>.<span class=\"ruby-identifier\">instance_variables</span>.<span class=\"ruby-identifier\">include?</span>( <span class=\"ruby-identifier\">sym</span>.<span class=\"ruby-identifier\">to_s</span> )\n\
      405:         }\n\
      406:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      407:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      408:             <span class=\"ruby-regexp re\">/assert_has_ivar/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      409:         }\n\
      410:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      411:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      412:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Assert that the specified <tt>object</tt> has an instance variable which
      matches the specified <tt>sym</tt>. The &#8217;@&#8217; at the beginning of
      the <tt>sym</tt> will be prepended if not present.
      </p>
    params: ( sym, object )
  - visibility: public
    aref: M000254
    name: assert_hash_equal
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 234</span>\n\
      234:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_hash_equal</span>( <span class=\"ruby-identifier\">expected</span>, <span class=\"ruby-identifier\">actual</span>, <span class=\"ruby-identifier\">msg</span>=<span class=\"ruby-value str\">&quot;&quot;</span> )\n\
      235:         <span class=\"ruby-identifier\">errmsg</span> = <span class=\"ruby-value str\">&quot;Expected hash &lt;%p&gt; to be equal to &lt;%p&gt;&quot;</span> <span class=\"ruby-operator\">%</span> [<span class=\"ruby-identifier\">expected</span>, <span class=\"ruby-identifier\">actual</span>]\n\
      236:         <span class=\"ruby-identifier\">errmsg</span> <span class=\"ruby-operator\">+=</span> <span class=\"ruby-node\">&quot;: #{msg}&quot;</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">msg</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      237: \n\
      238:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">errmsg</span> ) {\n\
      239:             <span class=\"ruby-identifier\">diffs</span> = <span class=\"ruby-identifier\">compare_hashes</span>( <span class=\"ruby-identifier\">expected</span>, <span class=\"ruby-identifier\">actual</span> )\n\
      240:             <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">diffs</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      241:                 <span class=\"ruby-identifier\">errmsg</span> <span class=\"ruby-operator\">+=</span> <span class=\"ruby-value str\">&quot;: &quot;</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-identifier\">diffs</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">&quot;; &quot;</span>)\n\
      242:                 <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">false</span>\n\
      243:             <span class=\"ruby-keyword kw\">else</span>\n\
      244:                 <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">true</span>\n\
      245:             <span class=\"ruby-keyword kw\">end</span>\n\
      246:         }\n\
      247:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      248:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      249:             <span class=\"ruby-regexp re\">/assert_hash_equal/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      250:         }\n\
      251:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      252:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      253:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Test Hashes for equivalent content
      </p>
    params: ( expected, actual, msg=&quot;&quot; )
  - visibility: public
    aref: M000258
    name: assert_include
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 333</span>\n\
      333:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_include</span>( <span class=\"ruby-identifier\">item</span>, <span class=\"ruby-identifier\">obj</span>, <span class=\"ruby-identifier\">msg</span>=<span class=\"ruby-keyword kw\">nil</span> )\n\
      334:         <span class=\"ruby-identifier\">msg</span> <span class=\"ruby-operator\">||=</span> <span class=\"ruby-value str\">&quot;&lt;%p&gt; expected to include &lt;%p&gt;.&quot;</span> <span class=\"ruby-operator\">%</span> [ <span class=\"ruby-identifier\">obj</span>, <span class=\"ruby-identifier\">item</span> ]\n\
      335:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">msg</span> ) { <span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">respond_to?</span>(<span class=\"ruby-identifier\">:include?</span>) <span class=\"ruby-operator\">&amp;&amp;</span> <span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">include?</span>(<span class=\"ruby-identifier\">item</span>) }\n\
      336:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      337:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      338:             <span class=\"ruby-regexp re\">/assert_include/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      339:         }\n\
      340:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      341:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      342:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Succeeds if <tt>obj</tt> include? <tt>item</tt>.
      </p>
    params: ( item, obj, msg=nil )
  - visibility: public
    aref: M000261
    name: assert_ivar_equal
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 379</span>\n\
      379:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_ivar_equal</span>( <span class=\"ruby-identifier\">value</span>, <span class=\"ruby-identifier\">object</span>, <span class=\"ruby-identifier\">sym</span> )\n\
      380:         <span class=\"ruby-identifier\">sym</span> = <span class=\"ruby-node\">&quot;@#{sym}&quot;</span>.<span class=\"ruby-identifier\">intern</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-regexp re\">/^@/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">sym</span>.<span class=\"ruby-identifier\">to_s</span>\n\
      381:         <span class=\"ruby-identifier\">msg</span> = <span class=\"ruby-value str\">&quot;Instance variable '%s'\\n\\tof &lt;%s&gt;\\n\\texpected to be &lt;%s&gt;\\n&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      382:             [ <span class=\"ruby-identifier\">sym</span>, <span class=\"ruby-identifier\">object</span>.<span class=\"ruby-identifier\">inspect</span>, <span class=\"ruby-identifier\">value</span>.<span class=\"ruby-identifier\">inspect</span> ]\n\
      383:         <span class=\"ruby-identifier\">msg</span> <span class=\"ruby-operator\">+=</span> <span class=\"ruby-value str\">&quot;\\tbut was: &lt;%p&gt;&quot;</span> <span class=\"ruby-operator\">%</span> [ <span class=\"ruby-identifier\">object</span>.<span class=\"ruby-identifier\">instance_variable_get</span>(<span class=\"ruby-identifier\">sym</span>) ]\n\
      384:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">msg</span> ) {\n\
      385:             <span class=\"ruby-identifier\">value</span> <span class=\"ruby-operator\">==</span> <span class=\"ruby-identifier\">object</span>.<span class=\"ruby-identifier\">instance_variable_get</span>(<span class=\"ruby-identifier\">sym</span>)\n\
      386:         }\n\
      387:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      388:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      389:             <span class=\"ruby-regexp re\">/assert_ivar_equal/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      390:         }\n\
      391:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      392:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      393:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Assert that the instance variable specified by <tt>sym</tt> of an
      <tt>object</tt> is equal to the specified <tt>value</tt>. The
      &#8217;@&#8217; at the beginning of the <tt>sym</tt> will be prepended if
      not present.
      </p>
    params: ( value, object, sym )
  - visibility: public
    aref: M000263
    name: assert_not_match
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 417</span>\n\
      417:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_not_match</span>( <span class=\"ruby-identifier\">re</span>, <span class=\"ruby-identifier\">str</span> )\n\
      418:         <span class=\"ruby-identifier\">msg</span> = <span class=\"ruby-value str\">&quot;&lt;%s&gt; expected not to match %p&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      419:             [ <span class=\"ruby-identifier\">str</span>, <span class=\"ruby-identifier\">re</span> ]\n\
      420:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">msg</span> ) {\n\
      421:             <span class=\"ruby-operator\">!</span><span class=\"ruby-identifier\">re</span>.<span class=\"ruby-identifier\">match</span>( <span class=\"ruby-identifier\">str</span> )\n\
      422:         }\n\
      423:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      424:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      425:             <span class=\"ruby-regexp re\">/assert_not_match/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      426:         }\n\
      427:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      428:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      429:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Assert that the specified <tt>str</tt> does <b>not</b> match the given
      regular expression <tt>re</tt>.
      </p>
    params: ( re, str )
  - visibility: public
    aref: M000257
    name: assert_not_nil
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 320</span>\n\
      320:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_not_nil</span>( <span class=\"ruby-identifier\">obj</span>, <span class=\"ruby-identifier\">msg</span>=<span class=\"ruby-keyword kw\">nil</span> )\n\
      321:         <span class=\"ruby-identifier\">msg</span> <span class=\"ruby-operator\">||=</span> <span class=\"ruby-value str\">&quot;&lt;%p&gt; expected to not be nil.&quot;</span> <span class=\"ruby-operator\">%</span> <span class=\"ruby-identifier\">obj</span>\n\
      322:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">msg</span> ) { <span class=\"ruby-operator\">!</span><span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">nil?</span> }\n\
      323:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      324:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      325:             <span class=\"ruby-regexp re\">/assert_not_nil/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      326:         }\n\
      327:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      328:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      329:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Override the stupid deprecated <a
      href="TestCase.html#M000257">#assert_not_nil</a> so when it disappears,
      code doesn&#8216;t break.
      </p>
    params: ( obj, msg=nil )
  - visibility: public
    aref: M000260
    name: assert_not_respond_to
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 361</span>\n\
      361:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_not_respond_to</span>( <span class=\"ruby-identifier\">obj</span>, <span class=\"ruby-identifier\">meth</span> )\n\
      362:         <span class=\"ruby-identifier\">msg</span> = <span class=\"ruby-value str\">&quot;%s expected NOT to respond to '%s'&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      363:             [ <span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">inspect</span>, <span class=\"ruby-identifier\">meth</span> ]\n\
      364:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">msg</span> ) {\n\
      365:             <span class=\"ruby-operator\">!</span><span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">respond_to?</span>( <span class=\"ruby-identifier\">meth</span> )\n\
      366:         }\n\
      367:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      368:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      369:             <span class=\"ruby-regexp re\">/assert_not_respond_to/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      370:         }\n\
      371:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      372:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      373:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Negative of assert_respond_to
      </p>
    params: ( obj, meth )
  - visibility: public
    aref: M000259
    name: assert_not_tainted
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 346</span>\n\
      346:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_not_tainted</span>( <span class=\"ruby-identifier\">obj</span>, <span class=\"ruby-identifier\">msg</span>=<span class=\"ruby-keyword kw\">nil</span> )\n\
      347:         <span class=\"ruby-identifier\">msg</span> <span class=\"ruby-operator\">||=</span> <span class=\"ruby-value str\">&quot;&lt;%p&gt; expected to NOT be tainted&quot;</span> <span class=\"ruby-operator\">%</span> [ <span class=\"ruby-identifier\">obj</span> ]\n\
      348:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">msg</span> ) {\n\
      349:             <span class=\"ruby-operator\">!</span><span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">tainted?</span>\n\
      350:         }\n\
      351:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      352:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      353:             <span class=\"ruby-regexp re\">/assert_not_tainted/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      354:         }\n\
      355:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      356:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      357:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Negative of assert_respond_to
      </p>
    params: ( obj, msg=nil )
  - visibility: public
    aref: M000256
    name: assert_same_keys
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 284</span>\n\
      284:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">assert_same_keys</span>( <span class=\"ruby-identifier\">expected</span>, <span class=\"ruby-identifier\">actual</span>, <span class=\"ruby-identifier\">msg</span>=<span class=\"ruby-value str\">&quot;&quot;</span> )\n\
      285:         <span class=\"ruby-identifier\">errmsg</span> = <span class=\"ruby-value str\">&quot;Expected keys of &lt;%p&gt; to be equal to those of &lt;%p&gt;&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      286:             [ <span class=\"ruby-identifier\">actual</span>, <span class=\"ruby-identifier\">expected</span> ]\n\
      287:         <span class=\"ruby-identifier\">errmsg</span> <span class=\"ruby-operator\">+=</span> <span class=\"ruby-node\">&quot;: #{msg}&quot;</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">msg</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      288: \n\
      289:         <span class=\"ruby-identifier\">ekeys</span> = <span class=\"ruby-identifier\">expected</span>.<span class=\"ruby-identifier\">keys</span>; <span class=\"ruby-identifier\">akeys</span> = <span class=\"ruby-identifier\">actual</span>.<span class=\"ruby-identifier\">keys</span>\n\
      290:         <span class=\"ruby-identifier\">assert_block</span>( <span class=\"ruby-identifier\">errmsg</span> ) {\n\
      291:             <span class=\"ruby-identifier\">diffs</span> = []\n\
      292: \n\
      293:             <span class=\"ruby-comment cmt\"># XOR the arrays and make a diff for each one</span>\n\
      294:             ((<span class=\"ruby-identifier\">ekeys</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-identifier\">akeys</span>) <span class=\"ruby-operator\">-</span> (<span class=\"ruby-identifier\">ekeys</span> <span class=\"ruby-operator\">&amp;</span> <span class=\"ruby-identifier\">akeys</span>)).<span class=\"ruby-identifier\">each</span> <span class=\"ruby-keyword kw\">do</span> <span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">key</span><span class=\"ruby-operator\">|</span>\n\
      295:                 <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">ekeys</span>.<span class=\"ruby-identifier\">include?</span>( <span class=\"ruby-identifier\">key</span> )\n\
      296:                     <span class=\"ruby-identifier\">diffs</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-value str\">&quot;missing key %p&quot;</span> <span class=\"ruby-operator\">%</span> [<span class=\"ruby-identifier\">key</span>]\n\
      297:                 <span class=\"ruby-keyword kw\">else</span>\n\
      298:                     <span class=\"ruby-identifier\">diffs</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-value str\">&quot;extra key %p&quot;</span> <span class=\"ruby-operator\">%</span> [<span class=\"ruby-identifier\">key</span>]\n\
      299:                 <span class=\"ruby-keyword kw\">end</span>\n\
      300:             <span class=\"ruby-keyword kw\">end</span>\n\
      301: \n\
      302:             <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">diffs</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      303:                 <span class=\"ruby-identifier\">errmsg</span> <span class=\"ruby-operator\">+=</span> <span class=\"ruby-value str\">&quot;\\n&quot;</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-identifier\">diffs</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">&quot;; &quot;</span>)\n\
      304:                 <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">false</span>\n\
      305:             <span class=\"ruby-keyword kw\">else</span>\n\
      306:                 <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">true</span>\n\
      307:             <span class=\"ruby-keyword kw\">end</span>\n\
      308:         }\n\
      309:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-constant\">Test</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Unit</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AssertionFailedError</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      310:         <span class=\"ruby-identifier\">cutframe</span> = <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">reverse</span>.<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">frame</span><span class=\"ruby-operator\">|</span>\n\
      311:             <span class=\"ruby-regexp re\">/assert_hash_equal/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-identifier\">frame</span>\n\
      312:         }\n\
      313:         <span class=\"ruby-identifier\">firstIdx</span> = (<span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">rindex</span>( <span class=\"ruby-identifier\">cutframe</span> )<span class=\"ruby-operator\">||</span><span class=\"ruby-value\">0</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>\n\
      314:         <span class=\"ruby-constant\">Kernel</span>.<span class=\"ruby-identifier\">raise</span>( <span class=\"ruby-identifier\">err</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>[<span class=\"ruby-identifier\">firstIdx</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span>] )\n\
      315:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Test Hashes (or any other objects with a #keys method) for key set equality
      </p>
    params: ( expected, actual, msg=&quot;&quot; )
  - visibility: public
    aref: M000271
    name: collectGarbage
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 502</span>\n\
      502:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">collectGarbage</span>\n\
      503:         <span class=\"ruby-identifier\">a</span> = []\n\
      504:         <span class=\"ruby-value\">1000</span>.<span class=\"ruby-identifier\">times</span> { <span class=\"ruby-identifier\">a</span> <span class=\"ruby-operator\">&lt;&lt;</span> {} }\n\
      505:         <span class=\"ruby-identifier\">a</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      506:         <span class=\"ruby-constant\">GC</span>.<span class=\"ruby-identifier\">start</span>\n\
      507:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Try to force garbage collection to start.
      </p>
    params: ()
  - visibility: public
    aref: M000255
    name: compare_hashes
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 258</span>\n\
      258:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">compare_hashes</span>( <span class=\"ruby-identifier\">hash1</span>, <span class=\"ruby-identifier\">hash2</span>, <span class=\"ruby-identifier\">subkeys</span>=<span class=\"ruby-keyword kw\">nil</span> )\n\
      259:         <span class=\"ruby-identifier\">diffs</span> = []\n\
      260:         <span class=\"ruby-identifier\">seenKeys</span> = []\n\
      261: \n\
      262:         <span class=\"ruby-identifier\">hash1</span>.<span class=\"ruby-identifier\">each</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">k</span>,<span class=\"ruby-identifier\">v</span><span class=\"ruby-operator\">|</span>\n\
      263:             <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-operator\">!</span><span class=\"ruby-identifier\">hash2</span>.<span class=\"ruby-identifier\">key?</span>( <span class=\"ruby-identifier\">k</span> )\n\
      264:                 <span class=\"ruby-identifier\">diffs</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-value str\">&quot;missing %p pair&quot;</span> <span class=\"ruby-operator\">%</span> <span class=\"ruby-identifier\">k</span>\n\
      265:             <span class=\"ruby-keyword kw\">elsif</span> <span class=\"ruby-identifier\">hash1</span>[<span class=\"ruby-identifier\">k</span>].<span class=\"ruby-identifier\">is_a?</span>( <span class=\"ruby-constant\">Hash</span> ) <span class=\"ruby-operator\">&amp;&amp;</span> <span class=\"ruby-identifier\">hash2</span>[<span class=\"ruby-identifier\">k</span>].<span class=\"ruby-identifier\">is_a?</span>( <span class=\"ruby-constant\">Hash</span> )\n\
      266:                 <span class=\"ruby-identifier\">diffs</span>.<span class=\"ruby-identifier\">push</span>( <span class=\"ruby-identifier\">compare_hashes</span>(<span class=\"ruby-identifier\">hash1</span>[<span class=\"ruby-identifier\">k</span>], <span class=\"ruby-identifier\">hash2</span>[<span class=\"ruby-identifier\">k</span>]) )\n\
      267:             <span class=\"ruby-keyword kw\">elsif</span> <span class=\"ruby-identifier\">hash2</span>[<span class=\"ruby-identifier\">k</span>] <span class=\"ruby-operator\">!=</span> <span class=\"ruby-identifier\">hash1</span>[<span class=\"ruby-identifier\">k</span>]\n\
      268:                 <span class=\"ruby-identifier\">diffs</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-value str\">&quot;value for %p expected to be %p, but was %p&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      269:                     [ <span class=\"ruby-identifier\">k</span>, <span class=\"ruby-identifier\">hash1</span>[<span class=\"ruby-identifier\">k</span>], <span class=\"ruby-identifier\">hash2</span>[<span class=\"ruby-identifier\">k</span>] ]\n\
      270:             <span class=\"ruby-keyword kw\">else</span>\n\
      271:                 <span class=\"ruby-identifier\">seenKeys</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-identifier\">k</span>\n\
      272:             <span class=\"ruby-keyword kw\">end</span>\n\
      273:         }\n\
      274: \n\
      275:         <span class=\"ruby-identifier\">extraKeys</span> = (<span class=\"ruby-identifier\">hash2</span>.<span class=\"ruby-identifier\">keys</span> <span class=\"ruby-operator\">-</span> <span class=\"ruby-identifier\">hash1</span>.<span class=\"ruby-identifier\">keys</span>)\n\
      276:         <span class=\"ruby-identifier\">diffs</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-node\">&quot;extra key/s: #{extraKeys.join(', ')}&quot;</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">extraKeys</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      277: \n\
      278:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">diffs</span>.<span class=\"ruby-identifier\">flatten</span>\n\
      279:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Compare two hashes for content, returning a list of their differences as
      descriptions. An empty Array return-value means they were the same.
      </p>
    params: ( hash1, hash2, subkeys=nil )
  - visibility: public
    aref: M000267
    name: debugMsg
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 467</span>\n\
      467:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">debugMsg</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">msgs</span> )\n\
      468:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">debugMsg</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">msgs</span> )\n\
      469:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Instance alias for the like-named class method
      </p>
    params: ( *msgs )
  - visibility: public
    aref: M000253
    name: default_test
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 227</span>\n\
      227:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">default_test</span>; <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Turn off the stupid &#8216;No tests were specified&#8216;
      </p>
    params: ()
  - visibility: public
    aref: M000268
    name: hrule
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 474</span>\n\
      474:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">hrule</span>( <span class=\"ruby-identifier\">length</span>=<span class=\"ruby-value\">75</span>, <span class=\"ruby-identifier\">char</span>=<span class=\"ruby-value str\">&quot;-&quot;</span> )\n\
      475:         <span class=\"ruby-keyword kw\">return</span> (<span class=\"ruby-identifier\">char</span> <span class=\"ruby-operator\">*</span> <span class=\"ruby-identifier\">length</span> ) <span class=\"ruby-operator\">+</span> <span class=\"ruby-value str\">&quot;\\n&quot;</span>\n\
      476:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return a separator line made up of <tt>length</tt> of the specified
      <tt>char</tt>.
      </p>
    params: ( length=75, char=&quot;-&quot; )
  - visibility: public
    aref: M000269
    name: hruleSection
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 480</span>\n\
      480:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">hruleSection</span>( <span class=\"ruby-identifier\">content</span>, <span class=\"ruby-identifier\">caption</span>=<span class=\"ruby-value str\">''</span> )\n\
      481:         <span class=\"ruby-identifier\">caption</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-value str\">' '</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">caption</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      482:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">caption</span> <span class=\"ruby-operator\">+</span>\n\
      483:             <span class=\"ruby-identifier\">hrule</span>( <span class=\"ruby-value\">75</span> <span class=\"ruby-operator\">-</span> <span class=\"ruby-identifier\">caption</span>.<span class=\"ruby-identifier\">length</span> ) <span class=\"ruby-operator\">+</span>\n\
      484:             <span class=\"ruby-identifier\">content</span>.<span class=\"ruby-identifier\">chomp</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-value str\">&quot;\\n&quot;</span> <span class=\"ruby-operator\">+</span>\n\
      485:             <span class=\"ruby-identifier\">hrule</span>()\n\
      486:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return a section delimited by hrules with the specified <tt>caption</tt>
      and <tt>content</tt>.
      </p>
    params: ( content, caption='' )
  - visibility: public
    aref: M000265
    name: message
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 455</span>\n\
      455:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">message</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">msgs</span> )\n\
      456:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">message</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">msgs</span> )\n\
      457:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Instance alias for the like-named class method.
      </p>
    params: ( *msgs )
  - visibility: public
    aref: M000270
    name: printTestHeader
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 490</span>\n\
      490:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">printTestHeader</span>( <span class=\"ruby-identifier\">desc</span> )\n\
      491:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">$VERBOSE</span> <span class=\"ruby-operator\">||</span> <span class=\"ruby-identifier\">$DEBUG</span>\n\
      492:         <span class=\"ruby-identifier\">message</span> <span class=\"ruby-value str\">&quot;%s&gt;&gt;&gt; %s &lt;&lt;&lt;%s&quot;</span> <span class=\"ruby-operator\">%</span> \n\
      493:             [ <span class=\"ruby-identifier\">ansiCode</span>(<span class=\"ruby-value str\">'bold'</span>,<span class=\"ruby-value str\">'yellow'</span>,<span class=\"ruby-value str\">'on_blue'</span>), <span class=\"ruby-identifier\">desc</span>, <span class=\"ruby-identifier\">ansiCode</span>(<span class=\"ruby-value str\">'reset'</span>) ]\n\
      494:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Output a header for delimiting tests
      </p>
    params: ( desc )
  - visibility: public
    aref: M000274
    name: prompt
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 547</span>\n\
      547:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">prompt</span>( <span class=\"ruby-identifier\">promptString</span> )\n\
      548:         <span class=\"ruby-identifier\">promptString</span>.<span class=\"ruby-identifier\">chomp!</span>\n\
      549:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">readline</span>( <span class=\"ruby-identifier\">ansiCode</span>(<span class=\"ruby-value str\">'bold'</span>, <span class=\"ruby-value str\">'green'</span>) <span class=\"ruby-operator\">+</span> <span class=\"ruby-node\">&quot;#{promptString}: &quot;</span> <span class=\"ruby-operator\">+</span>\n\
      550:                          <span class=\"ruby-identifier\">ansiCode</span>(<span class=\"ruby-value str\">'reset'</span>) ).<span class=\"ruby-identifier\">strip</span>\n\
      551:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Output the specified <tt>promptString</tt> as a <a
      href="TestCase.html#M000274">prompt</a> (in green) and return the
      user&#8216;s input with leading and trailing spaces removed.
      </p>
    params: ( promptString )
  - visibility: public
    aref: M000275
    name: promptWithDefault
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 557</span>\n\
      557:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">promptWithDefault</span>( <span class=\"ruby-identifier\">promptString</span>, <span class=\"ruby-identifier\">default</span> )\n\
      558:         <span class=\"ruby-identifier\">response</span> = <span class=\"ruby-identifier\">prompt</span>( <span class=\"ruby-value str\">&quot;%s [%s]&quot;</span> <span class=\"ruby-operator\">%</span> [ <span class=\"ruby-identifier\">promptString</span>, <span class=\"ruby-identifier\">default</span> ] )\n\
      559:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">response</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      560:             <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">default</span>\n\
      561:         <span class=\"ruby-keyword kw\">else</span>\n\
      562:             <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">response</span>\n\
      563:         <span class=\"ruby-keyword kw\">end</span>\n\
      564:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Prompt the user with the given <tt>promptString</tt> via <a
      href="TestCase.html#M000274">#prompt</a>, substituting the given
      <tt>default</tt> if the user doesn&#8216;t input anything.
      </p>
    params: ( promptString, default )
  - visibility: public
    aref: M000273
    name: run
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 518</span>\n\
      518:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">run</span>( <span class=\"ruby-identifier\">result</span> )\n\
      519:         <span class=\"ruby-identifier\">$stderr</span>.<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">name</span> <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">$VERBOSE</span> <span class=\"ruby-operator\">||</span> <span class=\"ruby-identifier\">$DEBUG</span>\n\
      520: \n\
      521:         <span class=\"ruby-comment cmt\"># Support debugging for individual tests</span>\n\
      522:         <span class=\"ruby-identifier\">olddb</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      523:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">$DebugPattern</span> <span class=\"ruby-operator\">&amp;&amp;</span> <span class=\"ruby-identifier\">$DebugPattern</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-ivar\">@method_name</span>\n\
      524:             <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Logger</span>.<span class=\"ruby-identifier\">global</span>.<span class=\"ruby-identifier\">outputters</span> <span class=\"ruby-operator\">&lt;&lt;</span>\n\
      525:                 <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Logger</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Outputter</span>.<span class=\"ruby-identifier\">create</span>( <span class=\"ruby-value str\">'file:stderr'</span> )\n\
      526:             <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Logger</span>.<span class=\"ruby-identifier\">global</span>.<span class=\"ruby-identifier\">level</span> = <span class=\"ruby-identifier\">:debug</span>\n\
      527: \n\
      528:             <span class=\"ruby-identifier\">olddb</span> = <span class=\"ruby-identifier\">$DEBUG</span>\n\
      529:             <span class=\"ruby-identifier\">$DEBUG</span> = <span class=\"ruby-keyword kw\">true</span>\n\
      530:         <span class=\"ruby-keyword kw\">end</span>\n\
      531:         \n\
      532:         <span class=\"ruby-keyword kw\">super</span>\n\
      533: \n\
      534:         <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">olddb</span>.<span class=\"ruby-identifier\">nil?</span>\n\
      535:             <span class=\"ruby-identifier\">$DEBUG</span> = <span class=\"ruby-identifier\">olddb</span> \n\
      536:             <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Logger</span>.<span class=\"ruby-identifier\">global</span>.<span class=\"ruby-identifier\">outputters</span>.<span class=\"ruby-identifier\">clear</span>\n\
      537:         <span class=\"ruby-keyword kw\">end</span>\n\
      538:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Output the name of the test as it&#8216;s running if in verbose mode.
      </p>
    params: ( result )
  - visibility: public
    aref: M000247
    name: set_up
    m_desc: |-
      <p>
      Alias for <a href="TestCase.html#M000246">#setup</a>
      </p>
    params: ( *args )
  - visibility: public
    aref: M000246
    name: setup
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 180</span>\n\
      180:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">setup</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      181:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span> <span class=\"ruby-operator\">&lt;</span> <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">TestCase</span>\n\
      182:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">setupMethods</span>.<span class=\"ruby-identifier\">each</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">sblock</span><span class=\"ruby-operator\">|</span>\n\
      183:                 <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">send</span>( <span class=\"ruby-identifier\">sblock</span> )\n\
      184:             }\n\
      185:         <span class=\"ruby-keyword kw\">end</span>\n\
      186:     <span class=\"ruby-keyword kw\">end</span>"
    aka: 
    - aref: TestCase.html#M000247
      name: set_up
    m_desc: |-
      <p>
      Run dynamically-added <a href="TestCase.html#M000246">setup</a> methods
      </p>
    params: ( *args )
  - visibility: public
    aref: M000250
    name: skip
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 202</span>\n\
      202:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">skip</span>( <span class=\"ruby-identifier\">reason</span>=<span class=\"ruby-keyword kw\">nil</span> )\n\
      203:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">reason</span>\n\
      204:             <span class=\"ruby-identifier\">msg</span> = <span class=\"ruby-value str\">&quot;Skipping %s: %s&quot;</span> <span class=\"ruby-operator\">%</span> [ <span class=\"ruby-ivar\">@method_name</span>, <span class=\"ruby-identifier\">reason</span> ]\n\
      205:         <span class=\"ruby-keyword kw\">else</span>\n\
      206:             <span class=\"ruby-identifier\">msg</span> = <span class=\"ruby-value str\">&quot;Skipping %s: No reason given.&quot;</span> <span class=\"ruby-operator\">%</span> <span class=\"ruby-ivar\">@method_name</span>\n\
      207:         <span class=\"ruby-keyword kw\">end</span>\n\
      208: \n\
      209:         <span class=\"ruby-identifier\">$stderr</span>.<span class=\"ruby-identifier\">puts</span>( <span class=\"ruby-identifier\">msg</span> ) <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">$VERBOSE</span>\n\
      210:         <span class=\"ruby-ivar\">@method_name</span> = <span class=\"ruby-identifier\">:skipped_test</span>\n\
      211:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Skip the current step (called from <a
      href="TestCase.html#M000246">#setup</a>) with the <tt>reason</tt> given.
      </p>
    params: ( reason=nil )
  - visibility: public
    aref: M000249
    name: tear_down
    m_desc: |-
      <p>
      Alias for <a href="TestCase.html#M000248">#teardown</a>
      </p>
    params: ( *args )
  - visibility: public
    aref: M000248
    name: teardown
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 191</span>\n\
      191:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">teardown</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      192:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span> <span class=\"ruby-operator\">&lt;</span> <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">TestCase</span>\n\
      193:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">teardownMethods</span>.<span class=\"ruby-identifier\">each</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">tblock</span><span class=\"ruby-operator\">|</span>\n\
      194:                 <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">send</span>( <span class=\"ruby-identifier\">tblock</span> )\n\
      195:             }\n\
      196:         <span class=\"ruby-keyword kw\">end</span>\n\
      197:     <span class=\"ruby-keyword kw\">end</span>"
    aka: 
    - aref: TestCase.html#M000249
      name: tear_down
    m_desc: |-
      <p>
      Run dynamically-added <a href="TestCase.html#M000248">teardown</a> methods
      </p>
    params: ( *args )
  - visibility: public
    aref: M000272
    name: zerofile
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/testcase.rb, line 511</span>\n\
      511:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">zerofile</span>( <span class=\"ruby-identifier\">filename</span> )\n\
      512:         <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">open</span>( <span class=\"ruby-identifier\">filename</span>, <span class=\"ruby-constant\">File</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">WRONLY</span><span class=\"ruby-operator\">|</span><span class=\"ruby-constant\">File</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">CREAT</span> ) {}\n\
      513:         <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">truncate</span>( <span class=\"ruby-identifier\">filename</span>, <span class=\"ruby-value\">0</span> )\n\
      514:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Touch a file and truncate it to 0 bytes
      </p>
    params: ( filename )
  category: Instance
  type: Public

sectitle

---

constants

--- 
- name: AnsiAttributes
  desc: |+
    
    Set some ANSI escape code constants (Shamelessly stolen from Perl&#8216;s
    Term::ANSIColor by Russ Allbery &lt;rra@stanford.edu&gt; and Zenin
    &lt;zenin@best.com&gt;
    
  value: "{         'clear'      =&gt; 0,         'reset'      =&gt; 0,         'bold'       =&gt; 1,         'dark'       =&gt; 2,         'underline'  =&gt; 4,         'underscore' =&gt; 4,         'blink'      =&gt; 5,         'reverse'    =&gt; 7,         'concealed'  =&gt; 8,          'black'      =&gt; 30,   'on_black'   =&gt; 40,          'red'        =&gt; 31,   'on_red'     =&gt; 41,          'green'      =&gt; 32,   'on_green'   =&gt; 42,          'yellow'     =&gt; 33,   'on_yellow'  =&gt; 43,          'blue'       =&gt; 34,   'on_blue'    =&gt; 44,          'magenta'    =&gt; 35,   'on_magenta' =&gt; 45,          'cyan'       =&gt; 36,   'on_cyan'    =&gt; 46,          'white'      =&gt; 37,   'on_white'   =&gt; 47"
- name: ConfigSaveFile
  desc: |+
    
    The name of the file containing marshalled configuration values
    
  value: "&quot;test.cfg&quot;"

In Files

Parent

Methods

Class Index