baby/big.rb

   1 #!/usr/bin/env ruby
   2
   3 require "testing.rb"
   4
   5 module Test_Big
   6
   7    include TestMod
   8
   9    # DO_TESTS = [:test_25_yields]
  10
  11    def test_24
  12          do_blah <<SRC, nil, [10508, 5221]
  13          class Blah
  14             def init
  15                alloc_self
  16                set 0, 0
  17             end
  18             def setdata ba
  19                set_self ba
  20             end
  21             def letters
  22                len = get 0
  23                pos = 0
  24                while true
  25                   pos += 1
  26                   yield get(pos)
  27                   if pos == len
  28                      break
  29                   end
  30                end
  31             end
  32             def print
  33                letters {
  34                   |char|
  35                   putch char
  36                }
  37                pi -5
  38             end
  39          end
  40          def times n
  41             ln = 0
  42             while ln < n
  43                ln += 1
  44                yield
  45             end
  46             pi -5
  47          end
  48          str = Blah.new
  49          str.init
  50          str.setdata "hello world\n"
  51          times(3) {
  52             str.print
  53          }
  54 SRC
  55    end
  56
  57    def test_25_yields
  58          do_blah <<SRC, nil, [21455, 11972]
  59          class Blah
  60             def init
  61                alloc_self
  62                set 0, 0
  63             end
  64             def setdata ba
  65                set_self ba
  66             end
  67             def letters
  68                len = get 0
  69                pos = 0
  70                while true
  71                   pos += 1
  72                   yield get(pos)
  73                   if pos == len
  74                      break
  75                   end
  76                end
  77             end
  78             def addchar ch
  79                set 0, (get 0) + 1
  80                set (get 0), ch
  81             end
  82             def print
  83                letters {
  84                   |char|
  85                   putch char
  86                }
  87             end
  88             def from_int num
  89                n = num
  90                pos = 0
  91                while n > 0
  92                   pos += 1
  93                   n /= 10
  94                end
  95                # alloc size (pos + 1) * 4
  96                size = pos
  97                set 0, size
  98                n = num
  99                while n > 0
 100                   ch = ?0 + n % 10
 101                   set pos, ch
 102                   n /= 10
 103                   pos += -1
 104                end
 105             end
 106             def concat str
 107                str.letters {
 108                   |ch|
 109                   addchar ch
 110                }
 111             end
 112             def length
 113                get 0
 114             end
 115          end
 116          def times n
 117             ln = 0
 118             while ln < n
 119                ln += 1
 120                yield
 121             end
 122          end
 123          def print_num int, just
 124             num = Blah.new
 125             num.init
 126             num.from_int int
 127             times(just - num.length) {
 128                putch ?\\s
 129             }
 130             num.print
 131          end
 132          def print_line m, just, num_columns
 133             n = 1
 134             times(num_columns) {
 135                print_num n * m, just
 136                n += 1
 137             }
 138             putch ?\\n
 139          end
 140          num_columns = 3
 141          num_rows    = 3
 142          max = Blah.new
 143          max.init
 144          max.from_int(num_columns * num_rows)
 145          just = 1 + max.length
 146          n = 1
 147          times(num_rows) {
 148             print_line n, just, num_columns
 149             n += 1
 150          }
 151 SRC
 152    end
 153
 154    def test_49
 155       n = ARGV.length > 0 ? ARGV.first.to_i : 3
 156       str_impl = (<<EOF)
 157          class Blah
 158             def init
 159                alloc_self
 160                set 0, 0
 161             end
 162             def letters
 163                len = get 0
 164                pos = 0
 165                while true
 166                   pos += 1
 167                   yield get(pos)
 168                   if pos == len
 169                      break
 170                   end
 171                end
 172             end
 173             def print
 174                letters {
 175                   |char|
 176                   putch char
 177                }
 178             end
 179             def from_int num
 180                n = num
 181                pos = 0
 182                while n > 0
 183                   pos += 1
 184                   n /= 10
 185                end
 186                # alloc size (pos + 1) * 4
 187                size = pos
 188                set 0, size
 189                n = num
 190                while n > 0
 191                   ch = ?0 + n % 10
 192                   set pos, ch
 193                   n /= 10
 194                   pos += -1
 195                end
 196             end
 197             def length
 198                get 0
 199             end
 200          end
 201          def from_and_to l, h
 202             ln = l
 203             while ln < h
 204                ln += 1
 205                yield ln
 206             end
 207          end
 208 EOF
 209          do_blah <<SRC, nil, [24019, 10709]
 210          #{str_impl}
 211       def print_spaces n
 212          from_and_to(1, n) {
 213             |n|
 214             putch ?\\s
 215          }
 216       end
 217       def boo t
 218          from_and_to(0, #{n}) {
 219             |n|
 220             num = Blah.new
 221             num.init
 222             num.from_int n * t
 223             print_spaces 5 - num.length
 224             num.print
 225          }
 226          putch ?\\n
 227       end
 228          from_and_to(0, #{n}) {
 229             |n|
 230             boo n
 231          }
 232 SRC
 233    end
 234
 235    public_instance_methods.each {
 236       |meth|
 237       next if meth !~ /^test.*/ or DO_TESTS.include? meth.to_sym
 238       remove_method meth.to_sym
 239    } if defined? DO_TESTS
 240 end