fto 0.1.0

data/test/test_fto_api.rb

@@ -0,0 +1,143 @@
+require 'rubygems'
+require 'ruby-debug'
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Test_FTO_API < Test::Unit::TestCase
+
+  include FormatText
+
+  private
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+
+  public
+
+  def test_arglistOverride()
+    cValue = 'construction value'
+    oValue = 'override value'
+    f = FTO.new('!AS', cValue)
+    assert_equal(cValue, f.format)
+    assert_equal(oValue, f.format(oValue))
+    assert_equal(cValue, f.format)
+  end                           #  def test_arglistOverride()
+
+  def test_findEffectors()
+    #
+    # Check for not finding anything
+    #
+    pattern = 'No such string'
+    assert(FTO::findEffectors(pattern).empty?)
+    assert(FTO::findEffectors(Regexp.new(pattern)).empty?)
+
+    #
+    # Check for finding exactly one match
+    #
+    pattern = '^TAB$'
+    assert(FTO::findEffectors(pattern).length == 1)
+    assert(FTO::findEffectors(Regexp.new(pattern)).length == 1)
+
+    #
+    # Make sure we're getting the right thing.
+    #
+    assert(FTO::findEffectors(pattern).first.class.name.match(/Effector/))
+
+    #
+    # Check for fiddling with case
+    #
+    pattern = '^tab$'
+    assert(FTO::findEffectors(pattern).empty?)
+    assert(FTO::findEffectors(Regexp.new(pattern, Regexp::IGNORECASE)).length == 1)
+
+    #
+    # Check for finding a few ('String AS', 'String AN', 'String AD',
+    # and 'String AF').
+    # Anchored pattern.
+    #
+    pattern = '^String'
+    assert(FTO::findEffectors(pattern).length == 4)
+    assert(FTO::findEffectors(Regexp.new(pattern)).length == 4)
+
+    #
+    # Check for finding a few ('Word: hex' and 'Quadword: hex').
+    # Unanchored pattern.
+    #
+    pattern = 'rd: he'
+    assert(FTO::findEffectors(pattern).length == 2)
+    assert(FTO::findEffectors(Regexp.new(pattern)).length == 2)
+  end                           # def test_findEffectors()
+
+  def test_EnableDisableEffector()
+    e = FTO.findEffectors('^String AS$').first
+    #
+    # Check the switches and sensors around enablement.  (Whether they
+    # actually do their jobs is next.)
+    #
+
+    #
+    # Instance methods checking an effector enabled by instance method.
+    # (Actually, by assumed default.)
+    #
+    assert(e.enabled?)
+    assert(! e.disabled?)
+
+    #
+    # Instance methods checking state altered by class method.
+    #
+    FTO.disableEffector(e.id)
+    assert(! e.enabled?)
+    assert(e.disabled?)
+
+    FTO.enableEffector(e.id)
+    assert(e.enabled?)
+    assert(! e.disabled?)
+
+    #
+    # *Now* instance methods checking on effect of other instance methods.
+    #
+    e.disable
+    assert(! e.enabled?)
+    assert(e.disabled?)
+
+    e.enable
+    assert(e.enabled?)
+    assert(! e.disabled?)
+
+    #
+    # Now time to see if this enable/disable stuff is really doing what it
+    # ought.
+    #
+    pattern = '!AS'
+    f = FTO.new(pattern, 'succeeded')
+    #
+    # Test reality of disablement using the Effector.disable method.
+    #
+    e.disable
+    assert_equal(pattern, f.format('succeeded'))
+    #
+    # Test reality of enablement using the FTO class method.
+    #
+    FTO.enableEffector(e.id)
+    assert_equal('succeeded', f.format('succeeded'))
+
+    #
+    # And contrariwise.  Class method first.
+    #
+    FTO.disableEffector(e.id)
+    assert_equal(pattern, f.format('succeeded'))
+    #
+    # Then instance method.
+    #
+    e.enable
+    assert_equal('succeeded', f.format('succeeded'))
+    #
+    # Make sure we leave it on!
+    #
+    FTO.enableEffector(e.id)
+  end                           # def test_EnableDisableEffector()
+
+end                             # class Test_FTO

data/test/test_fto_effectors.rb

@@ -0,0 +1,440 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Test_FTO < Test::Unit::TestCase
+
+  include FormatText
+
+  private
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+
+  def test_numeric_singleton(eff, val, expected)
+    assert_equal(expected, FTO.new(eff, val).format,
+                 'Testing ' + eff + '/' + val)
+  end
+
+  public
+
+  def test_insertions()
+    assert_equal(FTO.new('!_').format, "\011", 'Testing !_')
+    assert_equal(FTO.new('!,').format, "\012", 'Testing !,')
+    assert_equal(FTO.new('!^').format, "\014", 'Testing !^')
+    assert_equal(FTO.new('!=').format, "\015", 'Testing !=')
+    assert_equal(FTO.new('!/').format, "\015\012", 'Testing !/')
+    assert_equal(FTO.new('!!').format, '!', 'Testing !!')
+    assert_equal(FTO.new('!5**').format, '*****', 'Testing !n*c')
+  end                           # def test_insertions()
+
+  def test_fixedWidth()
+    test_data = '1234567890'
+    assert_equal(test_data,
+                 FTO.new('!10<!AS!>', test_data).format,
+                 'Testing :!10<!AS!>:10');
+    assert_equal('     ' + test_data,
+                 FTO.new('!15<!AS!>', test_data).format,
+                 'Testing :!15<!AS!>:10');
+    assert_equal('67890',
+                 FTO.new('!5<!AS!>', test_data).format,
+                 'Testing :!5<!AS!>:10');
+  end                           # def test_fixedWidth()
+
+  #
+  # Test that the recursion does by the Fixed Window effector function
+  # doesn't b0rk the argument list.
+  #
+  def test_fixedWidthArguments()
+    test_data = 'abc'
+    assert_equal('abc-abc-abc',
+                 FTO.new('!AS-!-!3<!AS!>-!-!AS', test_data).format,
+                 'Testing :!AS-!-!3<!AS!>-!-!AS:');
+    assert_equal('abc-abc-abc',
+                 FTO.new('!AS-!3<!-!AS!>-!-!AS', test_data).format,
+                 'Testing :!AS-!3<!-!AS!>-!-!AS:');
+    assert_equal('1-abc-3', 
+                 FTO.new('!UL-!3<!AS!>-!UL', 1, test_data, 3).format,
+                 'Testing :!AS-!3<!-!AS!>-!-!AS:');
+  end                           # def test_fixedWidthArguments
+
+  def test_unsized()
+    expectations = {
+      '-1'      => '255',
+      '0'       => '0',
+      '1'          => '1',
+      '0x100'      => '0',
+      '0xFFF'      => '255',
+      '0xFFFF'     => '255',
+      '0xFFFFF'    => '255',
+      '0xFFFFFF'   => '255',
+      '0xFFFFFFFF' => '255',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!UB', val, exp) }
+    expectations = {
+      '-1'         => '-1',
+      '0'          => '0',
+      '1'          => '1',
+      '0x100'      => '0',
+      '0xFFF'      => '-1',
+      '0xFFFF'     => '-1',
+      '0xFFFFF'    => '-1',
+      '0xFFFFFF'   => '-1',
+      '0xFFFFFFFF' => '-1',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!SB', val, exp) }
+    expectations = {
+      '-1'         => '255',
+      '0'          => '0',
+      '1'          => '1',
+      '0x100'      => '0',
+      '0xFFF'      => '255',
+      '0xFFFF'     => '255',
+      '0xFFFFF'    => '255',
+      '0xFFFFFF'   => '255',
+      '0xFFFFFFFF' => '255',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!ZB', val, exp) }
+    expectations = {
+      '-1'         => '377',
+      '0'          => '000',
+      '1'          => '001',
+      '0x100'      => '000',
+      '0xFFF'      => '377',
+      '0xFFFF'     => '377',
+      '0xFFFFF'    => '377',
+      '0xFFFFFF'   => '377',
+      '0xFFFFFFFF' => '377',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!OB', val, exp) }
+    expectations = {
+      '-1'         => 'FF',
+      '0'          => '00',
+      '1'          => '01',
+      '0x100'      => '00',
+      '0xFFF'      => 'FF',
+      '0xFFFF'     => 'FF',
+      '0xFFFFF'    => 'FF',
+      '0xFFFFFF'   => 'FF',
+      '0xFFFFFFFF' => 'FF',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!XB', val, exp) }
+    #
+    # Now the 16-bit word effectors
+    #
+    expectations = {
+      '-1'         => '65535',
+      '0'          => '0',
+      '1'          => '1',
+      '0x100'      => '256',
+      '0xFFF'      => '4095',
+      '0xFFFF'     => '65535',
+      '0xFFFFF'    => '65535',
+      '0xFFFFFF'   => '65535',
+      '0xFFFFFFFF' => '65535',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!UW', val, exp) }
+    expectations = {
+      '-1'         => '-1',
+      '0'          => '0',
+      '1'          => '1',
+      '0x100'      => '256',
+      '0xFFF'      => '4095',
+      '0xFFFF'     => '-1',
+      '0xFFFFF'    => '-1',
+      '0xFFFFFF'   => '-1',
+      '0xFFFFFFFF' => '-1',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!SW', val, exp) }
+    expectations = {
+      '-1'         => '65535',
+      '0'          => '0',
+      '1'          => '1',
+      '0x100'      => '256',
+      '0xFFF'      => '4095',
+      '0xFFFF'     => '65535',
+      '0xFFFFF'    => '65535',
+      '0xFFFFFF'   => '65535',
+      '0xFFFFFFFF' => '65535',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!ZW', val, exp) }
+    expectations = {
+      '-1'         => '177777',
+      '0'          => '000000',
+      '1'          => '000001',
+      '0x100'      => '000400',
+      '0xFFF'      => '007777',
+      '0xFFFF'     => '177777',
+      '0xFFFFF'    => '177777',
+      '0xFFFFFF'   => '177777',
+      '0xFFFFFFFF' => '177777',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!OW', val, exp) }
+    expectations = {
+      '-1'         => 'FFFF',
+      '0'          => '0000',
+      '1'          => '0001',
+      '0x100'      => '0100',
+      '0xFFF'      => '0FFF',
+      '0xFFFF'     => 'FFFF',
+      '0xFFFFF'    => 'FFFF',
+      '0xFFFFFF'   => 'FFFF',
+      '0xFFFFFFFF' => 'FFFF',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!XW', val, exp) }
+    #
+    # Now the 32-bit word effectors
+    #
+    expectations = {
+      '-1'         => '4294967295',
+      '0'          => '0',
+      '1'          => '1',
+      '0x100'      => '256',
+      '0xFFF'      => '4095',
+      '0xFFFF'     => '65535',
+      '0xFFFFF'    => '1048575',
+      '0xFFFFFF'   => '16777215',
+      '0xFFFFFFFF' => '4294967295',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!UL', val, exp) }
+    expectations = {
+      '-1'         => '-1',
+      '0'          => '0',
+      '1'          => '1',
+      '0x100'      => '256',
+      '0xFFF'      => '4095',
+      '0xFFFF'     => '65535',
+      '0xFFFFF'    => '1048575',
+      '0xFFFFFF'   => '16777215',
+      '0xFFFFFFFF' => '-1',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!SL', val, exp) }
+    expectations = {
+      '-1'         => '65535',
+      '0'          => '0',
+      '1'          => '1',
+      '0x100'      => '256',
+      '0xFFF'      => '4095',
+      '0xFFFF'     => '65535',
+      '0xFFFFF'    => '65535',
+      '0xFFFFFF'   => '65535',
+      '0xFFFFFFFF' => '65535',
+    }
+#    expectations.each { |val, exp| test_numeric_singleton('!ZL', val, exp) }
+    expectations = {
+      '-1'         => '37777777777',
+      '0'          => '00000000000',
+      '1'          => '00000000001',
+      '0x100'      => '00000000400',
+      '0xFFF'      => '00000007777',
+      '0xFFFF'     => '00000177777',
+      '0xFFFFF'    => '00003777777',
+      '0xFFFFFF'   => '00077777777',
+      '0xFFFFFFFF' => '37777777777',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!OL', val, exp) }
+    expectations = {
+      '-1'         => 'FFFFFFFF',
+      '0'          => '00000000',
+      '1'          => '00000001',
+      '0x100'      => '00000100',
+      '0xFFF'      => '00000FFF',
+      '0xFFFF'     => '0000FFFF',
+      '0xFFFFF'    => '000FFFFF',
+      '0xFFFFFF'   => '00FFFFFF',
+      '0xFFFFFFFF' => 'FFFFFFFF',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!XL', val, exp) }
+
+    #
+    # Now the 64-bit word effectors
+    #
+    expectations = {
+      '-1'                 => '18446744073709551615',
+      '0'                  => '0',
+      '1'                  => '1',
+      '0x100'              => '256',
+      '0xFFF'              => '4095',
+      '0xFFFF'             => '65535',
+      '0xFFFFF'            => '1048575',
+      '0xFFFFFF'           => '16777215',
+      '0xFFFFFFF'          => '268435455',
+      '0xFFFFFFFF'         => '4294967295',
+      '0xFFFFFFFFF'        => '68719476735',
+      '0xFFFFFFFFFF'       => '1099511627775',
+      '0xFFFFFFFFFFF'      => '17592186044415',
+      '0xFFFFFFFFFFFF'     => '281474976710655',
+      '0xFFFFFFFFFFFFF'    => '4503599627370495',
+      '0xFFFFFFFFFFFFFF'   => '72057594037927935',
+      '0xFFFFFFFFFFFFFFF'  => '1152921504606846975',
+      '0xFFFFFFFFFFFFFFFF' => '18446744073709551615',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!UQ', val, exp) }
+
+    expectations = {
+      '-1'                 => '-1',
+      '0'                  => '0',
+      '1'                  => '1',
+      '0x100'              => '256',
+      '0xFFF'              => '4095',
+      '0xFFFF'             => '65535',
+      '0xFFFFF'            => '1048575',
+      '0xFFFFFF'           => '16777215',
+      '0xFFFFFFF'          => '268435455',
+      '0xFFFFFFFF'         => '4294967295',
+      '0xFFFFFFFFF'        => '68719476735',
+      '0xFFFFFFFFFF'       => '1099511627775',
+      '0xFFFFFFFFFFF'      => '17592186044415',
+      '0xFFFFFFFFFFFF'     => '281474976710655',
+      '0xFFFFFFFFFFFFF'    => '4503599627370495',
+      '0xFFFFFFFFFFFFFF'   => '72057594037927935',
+      '0xFFFFFFFFFFFFFFF'  => '1152921504606846975',
+      '0xFFFFFFFFFFFFFFFF' => '-1',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!SQ', val, exp) }
+    expectations = {
+      '-1'                 => '18446744073709551615',
+      '0'                  => '0',
+      '1'                  => '1',
+      '0x100'              => '256',
+      '0xFFF'              => '4095',
+      '0xFFFF'             => '65535',
+      '0xFFFFF'            => '1048575',
+      '0xFFFFFF'           => '16777215',
+      '0xFFFFFFF'          => '268435455',
+      '0xFFFFFFFF'         => '4294967295',
+      '0xFFFFFFFFF'        => '68719476735',
+      '0xFFFFFFFFFF'       => '1099511627775',
+      '0xFFFFFFFFFFF'      => '17592186044415',
+      '0xFFFFFFFFFFFF'     => '281474976710655',
+      '0xFFFFFFFFFFFFF'    => '4503599627370495',
+      '0xFFFFFFFFFFFFFF'   => '72057594037927935',
+      '0xFFFFFFFFFFFFFFF'  => '1152921504606846975',
+      '0xFFFFFFFFFFFFFFFF' => '18446744073709551615',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!ZQ', val, exp) }
+    expectations = {
+      '-1'                 => '1777777777777777777777',
+      '0'                  => '0000000000000000000000',
+      '1'                  => '0000000000000000000001',
+      '0x100'              => '0000000000000000000400',
+      '0xFFF'              => '0000000000000000007777',
+      '0xFFFF'             => '0000000000000000177777',
+      '0xFFFFF'            => '0000000000000003777777',
+      '0xFFFFFF'           => '0000000000000077777777',
+      '0xFFFFFFF'          => '0000000000001777777777',
+      '0xFFFFFFFF'         => '0000000000037777777777',
+      '0xFFFFFFFFF'        => '0000000000777777777777',
+      '0xFFFFFFFFFF'       => '0000000017777777777777',
+      '0xFFFFFFFFFFF'      => '0000000377777777777777',
+      '0xFFFFFFFFFFFF'     => '0000007777777777777777',
+      '0xFFFFFFFFFFFFF'    => '0000177777777777777777',
+      '0xFFFFFFFFFFFFFF'   => '0003777777777777777777',
+      '0xFFFFFFFFFFFFFFF'  => '0077777777777777777777',
+      '0xFFFFFFFFFFFFFFFF' => '1777777777777777777777',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!OQ', val, exp) }
+    expectations = {
+      '-1'                 => 'FFFFFFFFFFFFFFFF',
+      '0'                  => '0000000000000000',
+      '1'                  => '0000000000000001',
+      '0x100'              => '0000000000000100',
+      '0xFFF'              => '0000000000000FFF',
+      '0xFFFF'             => '000000000000FFFF',
+      '0xFFFFF'            => '00000000000FFFFF',
+      '0xFFFFFF'           => '0000000000FFFFFF',
+      '0xFFFFFFF'          => '000000000FFFFFFF',
+      '0xFFFFFFFF'         => '00000000FFFFFFFF',
+      '0xFFFFFFFFF'        => '0000000FFFFFFFFF',
+      '0xFFFFFFFFFF'       => '000000FFFFFFFFFF',
+      '0xFFFFFFFFFFF'      => '00000FFFFFFFFFFF',
+      '0xFFFFFFFFFFFF'     => '0000FFFFFFFFFFFF',
+      '0xFFFFFFFFFFFFF'    => '000FFFFFFFFFFFFF',
+      '0xFFFFFFFFFFFFFF'   => '00FFFFFFFFFFFFFF',
+      '0xFFFFFFFFFFFFFFF'  => '0FFFFFFFFFFFFFFF',
+      '0xFFFFFFFFFFFFFFFF' => 'FFFFFFFFFFFFFFFF',
+    }
+    expectations.each { |val, exp| test_numeric_singleton('!XQ', val, exp) }
+  end                           # def test_unsized()
+
+  def test_strings()
+    testData = "A\001b\002C\003d\004E\005f\006G" +
+               "\007h\010I\011j\012K\013l\014M\015n"
+    dataLen = testData.length
+
+    assert_equal(':' + testData + ':',
+                 FTO.new(':!AS:', testData).format,
+                 "Testing :!AS:[0,#{dataLen}]")
+    assert_equal(':' + testData[0,5] + ':',
+                 FTO.new(':!5AS:', testData).format,
+                 "Testing :!5AS:[0,#{dataLen}]")
+    assert_equal(':' + testData[0,5] + (' ' * 5) + ':',
+                 FTO.new(':!10AS:', testData[0,5]).format,
+                 "Testing :!10AS:[0,5]")
+    assert_equal(':' + testData[0,5] + ':',
+                 FTO.new(':!5AS:', testData[0,5]).format,
+                 "Testing :!5AS:[0,5]")
+
+    assert_equal(':A.b.C.d.E.f.G.h.I.j.K.l.M.n:',
+                 FTO.new(':!AN:', testData).format,
+                 "Testing :!AN:[0,#{dataLen}]")
+    assert_equal(':A.b.C:',
+                 FTO.new(':!5AN:', testData).format,
+                 "Testing :!5AN:[0,#{dataLen}]")
+    assert_equal(':A.b.C     :',
+                 FTO.new(':!10AN:', testData[0,5]).format,
+                 "Testing :!10AN:[0,5]")
+    assert_equal(':A.b.C:',
+                 FTO.new(':!5AN:', testData[0,5]).format,
+                 "Testing :!5AN:[0,5]")
+
+    assert_equal(':A.b.C.d.E.:',
+                 FTO.new(':!AF:', 10, testData).format,
+                 "Testing :!AF:10,[0,#{dataLen}]")
+    assert_equal(':A.b.C:',
+                 FTO.new(':!5AF:', 10, testData).format,
+                 "Testing :!5AF:10,[0,#{dataLen}]")
+    assert_equal(':A.b.C.....:',
+                 FTO.new(':!10AF:', 10, testData[0,5]).format,
+                 "Testing :!10AF:10,[0,5]")
+    assert_equal(':A.b.C.....:',
+                 FTO.new(':!AF:', 10, testData[0,5]).format,
+                 "Testing :!AF:10,[0,5]")
+
+    assert_equal(':' + testData[0,10] + ':',
+                 FTO.new(':!AD:', 10, testData).format,
+                 "Testing :!AD:10,[0,#{dataLen}]")
+    assert_equal(':' + testData[0,5] + ':',
+                 FTO.new(':!5AD:', 10, testData).format,
+                 "Testing :!5AD:10,[0,#{dataLen}]")
+    assert_equal(':' + testData[0,5] + ("\000" * 5) + ':',
+                 FTO.new(':!10AD:', 10, testData[0,5]).format,
+                 "Testing :!10AD:10,[0,5]")
+    assert_equal(':' + testData[0,5] + ("\000" * 5) + ':',
+                 FTO.new(':!AD:', 10, testData[0,5]).format,
+                 "Testing :!AD:10,[0,5]")
+  end                           # def test_strings()
+
+  def test_plurals()
+    assert_equal(FTO.new('I have !SB boat!%S', -1).format, 'I have -1 boats')
+    assert_equal(FTO.new('I HAVE !SB BOAT!%S', -1).format, 'I HAVE -1 BOATS')
+    assert_equal(FTO.new('I have !SB boat!%S', 0).format, 'I have 0 boats')
+    assert_equal(FTO.new('I HAVE !SB BOAT!%S', 0).format, 'I HAVE 0 BOATS')
+    assert_equal(FTO.new('I have !SB boat!%S', 1).format, 'I have 1 boat')
+    assert_equal(FTO.new('I HAVE !SB BOAT!%S', 1).format, 'I HAVE 1 BOAT')
+    assert_equal(FTO.new('I have !SB boat!%S', 2).format, 'I have 2 boats')
+    assert_equal(FTO.new('I HAVE !SB BOAT!%S', 2).format, 'I HAVE 2 BOATS')
+
+    assert_equal(FTO.new('!SB boat!%S !%is cool', -1).format, '-1 boats are cool')
+    assert_equal(FTO.new('!SB BOAT!%S !%IS COOL', -1).format, '-1 BOATS ARE COOL')
+    assert_equal(FTO.new('!SB boat!%S !%is cool', 0).format, '0 boats are cool')
+    assert_equal(FTO.new('!SB BOAT!%S !%IS COOL', 0).format, '0 BOATS ARE COOL')
+    assert_equal(FTO.new('!SB boat!%S !%is cool', 1).format, '1 boat is cool')
+    assert_equal(FTO.new('!SB BOAT!%S !%IS COOL', 1).format, '1 BOAT IS COOL')
+    assert_equal(FTO.new('!SB boat!%S !%is cool', 2).format, '2 boats are cool')
+    assert_equal(FTO.new('!SB BOAT!%S !%IS COOL', 2).format, '2 BOATS ARE COOL')
+  end                           # def test_plurals()
+
+end                             # class Test_FTO