test/bfts/test_range.rb

   1 require 'rubicon_testcase'
   2
   3 class TestRange < RubiconTestCase
   4
   5   ############################################################
   6   # Test Utilities:
   7
   8   #
   9   # Tests where the methods == and eql? behave the same.
  10   # This is true when the class of the endpoints of
  11   # the Range have == and eql? methods that are
  12   # aliases. This in turn is true for most classes,
  13   # for example for the class used here: Fixnum.
  14   #
  15   # TODO: write tests using an endpoint class where
  16   # the methods  == and eql? differ.
  17   #
  18   def util_test_equals(method)
  19
  20     r25 = Range.new(2, 5)
  21     r34 = Range.new(3, 4)
  22     r35 = Range.new(3, 5)
  23     r36 = Range.new(3, 6)
  24     r45 = Range.new(4, 5)
  25     rx25 = Range.new(2, 5, true)
  26     rx34 = Range.new(3, 4, true)
  27     rx35 = Range.new(3, 5, true)
  28     rx36 = Range.new(3, 6, true)
  29     rx45 = Range.new(4, 5, true)
  30
  31     # closed interval
  32     assert_equal(false, r35.send(method, r34))
  33     assert_equal(true,  r35.send(method, r35))
  34     assert_equal(false, r35.send(method, r36))
  35
  36     assert_equal(false, r35.send(method, r25))
  37     assert_equal(false, r35.send(method, r45))
  38
  39     # half-open interval
  40     assert_equal(false, rx35.send(method, rx34))
  41     assert_equal(true,  rx35.send(method, rx35))
  42     assert_equal(false, rx35.send(method, rx36))
  43
  44     assert_equal(false, rx35.send(method, rx25))
  45     assert_equal(false, rx35.send(method, rx45))
  46
  47     # half-open / closed interval: never equal
  48     assert_equal(false, rx35.send(method, r34))
  49     assert_equal(false, rx35.send(method, r35))
  50     assert_equal(false, rx35.send(method, r36))
  51
  52     assert_equal(false, rx35.send(method, r25))
  53     assert_equal(false, rx35.send(method, r45))
  54
  55     # closed / half-open interval: never equal
  56     assert_equal(false, r35.send(method, rx34))
  57     assert_equal(false, r35.send(method, rx35))
  58     assert_equal(false, r35.send(method, rx36))
  59
  60     assert_equal(false, r35.send(method, rx25))
  61     assert_equal(false, r35.send(method, rx45))
  62
  63     # non-Range argument
  64     assert_equal(false, r35.send(method, Object.new))
  65     assert_equal(false, rx35.send(method, Object.new))
  66
  67   end
  68
  69   def util_test_end(msg)
  70     assert_equal(10, Range.new(1, 10).send(msg))
  71     assert_equal(11, Range.new(1, 11, true).send(msg))
  72     assert_equal("z", Range.new("a", "z").send(msg))
  73     assert_equal("A", Range.new("a", "A", true).send(msg))
  74   end
  75
  76   def util_member(method)
  77     is = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
  78     xs = is.map {|x| 0.5 + x}
  79     iss = ["aj", "ak", "al", "am", "an" ,"ao" "ap"]
  80     xss = ["ajjj", "akkk", "alll", "ammm", "annn" ,"aooo" "appp"]
  81
  82     r47  = Range.new(4, 7)
  83     rx47 = Range.new(4, 7, true)
  84     r_akam  = Range.new("ak", "am")
  85     rx_akam = Range.new("ak", "am", true)
  86
  87     # as discrete range
  88     assert_equal([4, 5, 6, 7 ], is.select {|i| r47.send(method, i) })
  89     assert_equal([4, 5, 6],     is.select {|i| rx47.send(method, i) })
  90
  91     assert_equal(["ak","al","am"], iss.select {|i| r_akam.send(method, i) })
  92     assert_equal(["ak","al"],      iss.select {|i| rx_akam.send(method, i) })
  93
  94     # as continuous range
  95     assert_equal([4.5, 5.5, 6.5], xs.select {|x| r47.send(method, x) })
  96     assert_equal([4.5, 5.5, 6.5], xs.select {|x| rx47.send(method, x) })
  97
  98     assert_equal(["akkk","alll"], xss.select {|i| r_akam.send(method, i) })
  99     assert_equal(["akkk","alll"], xss.select {|i| rx_akam.send(method, i) })
 100
 101     # non-comparable argument
 102     assert_equal(false, Range.new(5, 10)  === Object.new)
 103     assert_equal(false, Range.new(5, 10, true) === Object.new)
 104   end
 105
 106   def util_step_tester(acc_facit, range, *step_args)
 107     acc = []
 108     res = range.step(*step_args) {|x| acc << x }
 109     assert_equal(acc_facit, acc)
 110     assert_same(range, res)
 111   end
 112
 113   def util_each(first, last, exclude, expected)
 114     index = first
 115     count = 0
 116     Range.new(first, last, exclude).each do |x|
 117       assert_equal(index, x)
 118       index = index.succ
 119       count += 1
 120     end
 121     assert_equal(expected, count)
 122   end
 123
 124   ############################################################
 125   # Test Methods
 126
 127   # TODO: need to test new/initialize, esp w/ bad values
 128
 129   def test_begin
 130     assert_equal(1,   Range.new(1, 10).begin)
 131     assert_equal("a", Range.new("a", "z").begin)
 132     assert_equal(1,   Range.new(1, 10, true).begin)
 133     assert_equal("a", Range.new("a", "z", true).begin)
 134   end
 135
 136   def test_each
 137     util_each(1, 10, false, 10)
 138     util_each(1, 10,  true,  9)
 139
 140     util_each("A", "J", false, 10)
 141     util_each("A", "J",  true,  9)
 142
 143     # TODO: test something that has a .succ, but is neither int nor string
 144     t1 = Time.at(1)
 145     t10 = Time.at(10)
 146     util_each(t1, t10, false, 10)
 147     util_each(t1, t10,  true,  9)
 148
 149     # test something that has no .succ:
 150 # HACK:
 151 #    util_each(Object.new, Object.new, false, 10)
 152 #    util_each(Object.new, Object.new,  true,  9)
 153   end
 154
 155   def test_end
 156     util_test_end(:end)
 157   end
 158
 159   def test_eql_eh
 160     util_test_equals(:eql?)
 161   end
 162
 163   def test_equals2 # '=='
 164     util_test_equals(:==)
 165   end
 166
 167   def test_equals3 # '==='
 168     util_member(:===)
 169
 170     # misc
 171     gotit = false
 172     case 52
 173       when Range.new(0, 49)
 174         fail("Shouldn't have matched")
 175       when Range.new(50, 75)
 176         gotit = true
 177       else
 178         fail("Shouldn't have matched")
 179     end
 180     assert_equal(true,gotit)
 181
 182     gotit = false
 183     case 50
 184       when Range.new(0, 49)
 185         fail("Shouldn't have matched")
 186       when Range.new(50, 75)
 187         gotit = true
 188       else
 189         fail("Shouldn't have matched")
 190     end
 191     assert_equal(true,gotit)
 192
 193     gotit = false
 194     case 75
 195       when Range.new(0, 49)
 196         fail("Shouldn't have matched")
 197       when Range.new(50, 75)
 198         gotit = true
 199       else
 200         fail("Shouldn't have matched")
 201     end
 202     assert_equal(true,gotit)
 203   end
 204
 205   def test_exclude_end_eh
 206     assert_equal(true, Range.new(1, 10, true).exclude_end?)
 207     assert_equal(false,Range.new(1, 10).exclude_end?)
 208     assert_equal(true, Range.new("A", "Z", true).exclude_end?)
 209     assert_equal(false,Range.new("A", "Z").exclude_end?)
 210   end
 211
 212   def test_first
 213     assert_equal(1, Range.new(1, 10).first)
 214     assert_equal("a", Range.new("a", "z").first)
 215     assert_equal(1, Range.new(1, 10, true).first)
 216     assert_equal("a", Range.new("a", "z", true).first)
 217   end
 218
 219   def test_hash
 220     assert_equal(Range.new(5, 9).hash, Range.new(5, 9).hash)
 221     assert_equal(Range.new("A", "Z").hash, Range.new("A", "Z").hash)
 222
 223     assert_equal(Range.new(5, 9, true).hash, Range.new(5, 9, true).hash)
 224     assert_equal(Range.new("A", "Z", true).hash, Range.new("A", "Z", true).hash)
 225
 226     assert_not_equal(Range.new(5, 9).hash, Range.new(5, 9, true).hash)
 227     assert_not_equal(Range.new("A", "Z").hash, Range.new("A", "Z", true).hash)
 228
 229     assert_not_equal(Range.new(5, 9).hash, Range.new(5, 8).hash)
 230     assert_not_equal(Range.new("A", "Z").hash, Range.new("a", "Z", true).hash)
 231   end
 232
 233   def test_include_eh
 234     util_member(:include?)
 235   end
 236
 237   def test_inspect
 238     assert_equal('1..10', Range.new(1, 10).inspect)
 239     assert_equal('1...10', Range.new(1, 10, true).inspect)
 240     assert_equal('"a".."z"', Range.new('a', 'z').inspect)
 241     assert_equal('"a"..."z"', Range.new('a', 'z', true).inspect)
 242   end
 243
 244   def test_last
 245     util_test_end(:last)
 246   end
 247
 248   def test_member_eh
 249     util_member(:member?)
 250   end
 251
 252   def test_step
 253     # n=1 default in step(n)
 254     util_step_tester([5,6,7,8,9], Range.new(5, 9))
 255     util_step_tester([5,6,7,8],   Range.new(5, 9, true))
 256
 257     # explicit n=1
 258     util_step_tester([5,6,7,8,9], Range.new(5, 9),   1)
 259     util_step_tester([5,6,7,8],   Range.new(5, 9, true),  1)
 260
 261     # n=2
 262     util_step_tester([5,7,9],     Range.new(5, 9),   2)
 263     util_step_tester([5,7],       Range.new(5, 9, true),  2)
 264
 265     # n=3
 266     util_step_tester([5,8],       Range.new(5, 9),   3)
 267     util_step_tester([5,8],       Range.new(5, 9, true),  3)
 268
 269     # n=4
 270     util_step_tester([5,9],       Range.new(5, 9),   4)
 271     util_step_tester([5],         Range.new(5, 9, true),  4)
 272   end
 273
 274   def test_to_s
 275     assert_equal('1..10', Range.new(1, 10).to_s)
 276     assert_equal('1...10', Range.new(1, 10, true).to_s)
 277     assert_equal('a..z', Range.new('a', 'z').to_s)
 278     assert_equal('a...z', Range.new('a', 'z', true).to_s)
 279   end
 280 end