for_all.pony

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
use "pony_test"

class ForAll[T]
  """
  Runs a single-argument property check inline within a `UnitTest`.
  """
  let _gen: Generator[T] val
  let _helper: TestHelper

  new create(gen': Generator[T] val, test_helper: TestHelper) =>
    _gen = gen'
    _helper = test_helper

  fun ref apply(prop: {(T, PropertyHelper) ?} val) ? =>
    """
    execute
    """
    Property1UnitTest[T](
      object iso is Property1[T]
        fun name(): String => ""

        fun gen(): Generator[T] => _gen

        fun ref property(arg1: T, h: PropertyHelper) ? =>
          prop(consume arg1, h)?
      end
    ).apply(_helper)?

class ForAll2[T1, T2]
  """
  Runs a two-argument property check inline within a `UnitTest`.
  """
  let _gen1: Generator[T1] val
  let _gen2: Generator[T2] val
  let _helper: TestHelper

  new create(
    gen1': Generator[T1] val,
    gen2': Generator[T2] val,
    h: TestHelper)
  =>
    _gen1 = gen1'
    _gen2 = gen2'
    _helper = h

  fun ref apply(prop: {(T1, T2, PropertyHelper) ?} val) ? =>
    Property2UnitTest[T1, T2](
      object iso is Property2[T1, T2]
        fun name(): String => ""
        fun gen1(): Generator[T1] => _gen1
        fun gen2(): Generator[T2] => _gen2
        fun ref property2(arg1: T1, arg2: T2, h: PropertyHelper) ? =>
          prop(consume arg1, consume arg2, h)?
      end
    ).apply(_helper)?

class ForAll3[T1, T2, T3]
  """
  Runs a three-argument property check inline within a `UnitTest`.
  """
  let _gen1: Generator[T1] val
  let _gen2: Generator[T2] val
  let _gen3: Generator[T3] val
  let _helper: TestHelper

  new create(
    gen1': Generator[T1] val,
    gen2': Generator[T2] val,
    gen3': Generator[T3] val,
    h: TestHelper)
  =>
    _gen1 = gen1'
    _gen2 = gen2'
    _gen3 = gen3'
    _helper = h

  fun ref apply(prop: {(T1, T2, T3, PropertyHelper) ?} val) ? =>
    Property3UnitTest[T1, T2, T3](
      object iso is Property3[T1, T2, T3]
        fun name(): String => ""
        fun gen1(): Generator[T1] => _gen1
        fun gen2(): Generator[T2] => _gen2
        fun gen3(): Generator[T3] => _gen3
        fun ref property3(arg1: T1, arg2: T2, arg3: T3, h: PropertyHelper) ? =>
          prop(consume arg1, consume arg2, consume arg3, h)?
      end
    ).apply(_helper)?

class ForAll4[T1, T2, T3, T4]
  """
  Runs a four-argument property check inline within a `UnitTest`.
  """
  let _gen1: Generator[T1] val
  let _gen2: Generator[T2] val
  let _gen3: Generator[T3] val
  let _gen4: Generator[T4] val
  let _helper: TestHelper

  new create(
    gen1': Generator[T1] val,
    gen2': Generator[T2] val,
    gen3': Generator[T3] val,
    gen4': Generator[T4] val,
    h: TestHelper)
  =>
    _gen1 = gen1'
    _gen2 = gen2'
    _gen3 = gen3'
    _gen4 = gen4'
    _helper = h

  fun ref apply(prop: {(T1, T2, T3, T4, PropertyHelper) ?} val) ? =>
    Property4UnitTest[T1, T2, T3, T4](
      object iso is Property4[T1, T2, T3, T4]
        fun name(): String => ""
        fun gen1(): Generator[T1] => _gen1
        fun gen2(): Generator[T2] => _gen2
        fun gen3(): Generator[T3] => _gen3
        fun gen4(): Generator[T4] => _gen4
        fun ref property4(
          arg1: T1,
          arg2: T2,
          arg3: T3,
          arg4: T4,
          h: PropertyHelper)
          ?
        =>
          prop(
            consume arg1,
            consume arg2,
            consume arg3,
            consume arg4,
            h)?
      end
    ).apply(_helper)?