Development

Changeset 20958

You must first sign up to be able to contribute.

Changeset 20958

Show
Ignore:
Timestamp:
08/09/09 14:52:07 (5 years ago)
Author:
bschussek
Message:

Renamed LimeTesterException? to LimeAssertionFailedException? and removed deprecated LimeNotEqualException?

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • tools/lime/branches/2.0-experimental/lib/LimeAssertionFailedException.php

    r20701 r20958  
    1010 */ 
    1111 
    12 class LimeTesterException extends Exception 
     12class LimeAssertionFailedException extends Exception 
    1313{ 
    1414  private 
  • tools/lime/branches/2.0-experimental/lib/LimeTest.php

    r20704 r20958  
    150150      return $this->pass($message); 
    151151    } 
    152     catch (LimeTesterException $e) 
     152    catch (LimeAssertionFailedException $e) 
    153153    { 
    154154      $error = sprintf("     got: %s\nexpected: %s", $e->getActual(10), $e->getExpected(10)); 
     
    178178      return $this->pass($message); 
    179179    } 
    180     catch (LimeTesterException $e) 
     180    catch (LimeAssertionFailedException $e) 
    181181    { 
    182182      $error = sprintf("     got: %s\nexpected: %s", $e->getActual(10), $e->getExpected(10)); 
     
    206206      return $this->pass($message); 
    207207    } 
    208     catch (LimeTesterException $e) 
     208    catch (LimeAssertionFailedException $e) 
    209209    { 
    210210      $error = sprintf("%s\n    must not be\n%s", $e->getActual(), $e->getExpected()); 
     
    234234      return $this->pass($message); 
    235235    } 
    236     catch (LimeTesterException $e) 
     236    catch (LimeAssertionFailedException $e) 
    237237    { 
    238238      $error = sprintf("%s\n    must not be\n%s", $e->getActual(), $e->getExpected()); 
     
    262262      return $this->pass($message); 
    263263    } 
    264     catch (LimeTesterException $e) 
     264    catch (LimeAssertionFailedException $e) 
    265265    { 
    266266      $error = sprintf("              %s\ndoesn't match %s", $e->getActual(), $e->getExpected()); 
     
    290290      return $this->pass($message); 
    291291    } 
    292     catch (LimeTesterException $e) 
     292    catch (LimeAssertionFailedException $e) 
    293293    { 
    294294      $error = sprintf("         %s\nmatches %s", $e->getActual(), $e->getExpected()); 
     
    309309      return $this->pass($message); 
    310310    } 
    311     catch (LimeTesterException $e) 
     311    catch (LimeAssertionFailedException $e) 
    312312    { 
    313313      $error = sprintf("         %s\nis not > %s", $e->getActual(), $e->getExpected()); 
     
    328328      return $this->pass($message); 
    329329    } 
    330     catch (LimeTesterException $e) 
     330    catch (LimeAssertionFailedException $e) 
    331331    { 
    332332      $error = sprintf("          %s\nis not >= %s", $e->getActual(), $e->getExpected()); 
     
    347347      return $this->pass($message); 
    348348    } 
    349     catch (LimeTesterException $e) 
     349    catch (LimeAssertionFailedException $e) 
    350350    { 
    351351      $error = sprintf("         %s\nis not < %s", $e->getActual(), $e->getExpected()); 
     
    366366      return $this->pass($message); 
    367367    } 
    368     catch (LimeTesterException $e) 
     368    catch (LimeAssertionFailedException $e) 
    369369    { 
    370370      $error = sprintf("          %s\nis not <= %s", $e->getActual(), $e->getExpected()); 
     
    420420      return $this->pass($message); 
    421421    } 
    422     catch (LimeTesterException $e) 
     422    catch (LimeAssertionFailedException $e) 
    423423    { 
    424424      $error = sprintf("%s\n    doesn't contain\n%s", $e->getActual(), $e->getExpected()); 
     
    439439      return $this->pass($message); 
    440440    } 
    441     catch (LimeTesterException $e) 
     441    catch (LimeAssertionFailedException $e) 
    442442    { 
    443443      $error = sprintf("%s\n    must not contain\n%s", $e->getActual(), $e->getExpected()); 
  • tools/lime/branches/2.0-experimental/lib/mock/LimeMockInvocation.php

    r20957 r20958  
    7878      return $equal; 
    7979    } 
    80     catch (LimeTesterException $e) 
     80    catch (LimeAssertionFailedException $e) 
    8181    { 
    8282      return false; 
  • tools/lime/branches/2.0-experimental/lib/tester/LimeTester.php

    r20701 r20958  
    112112  public function assertEquals(LimeTesterInterface $expected) 
    113113  { 
    114     throw new LimeTesterException($this, $expected); 
     114    throw new LimeAssertionFailedException($this, $expected); 
    115115  } 
    116116 
    117117  public function assertNotEquals(LimeTesterInterface $expected) 
    118118  { 
    119     throw new LimeTesterException($this, $expected); 
     119    throw new LimeAssertionFailedException($this, $expected); 
    120120  } 
    121121 
    122122  public function assertSame(LimeTesterInterface $expected) 
    123123  { 
    124     throw new LimeTesterException($this, $expected); 
     124    throw new LimeAssertionFailedException($this, $expected); 
    125125  } 
    126126 
    127127  public function assertNotSame(LimeTesterInterface $expected) 
    128128  { 
    129     throw new LimeTesterException($this, $expected); 
     129    throw new LimeAssertionFailedException($this, $expected); 
    130130  } 
    131131 
    132132  public function assertLike(LimeTesterInterface $expected) 
    133133  { 
    134     throw new LimeTesterException($this, $expected); 
     134    throw new LimeAssertionFailedException($this, $expected); 
    135135  } 
    136136 
    137137  public function assertUnlike(LimeTesterInterface $expected) 
    138138  { 
    139     throw new LimeTesterException($this, $expected); 
     139    throw new LimeAssertionFailedException($this, $expected); 
    140140  } 
    141141 
    142142  public function assertGreaterThan(LimeTesterInterface $expected) 
    143143  { 
    144     throw new LimeTesterException($this, $expected); 
     144    throw new LimeAssertionFailedException($this, $expected); 
    145145  } 
    146146 
    147147  public function assertGreaterThanOrEqual(LimeTesterInterface $expected) 
    148148  { 
    149     throw new LimeTesterException($this, $expected); 
     149    throw new LimeAssertionFailedException($this, $expected); 
    150150  } 
    151151 
    152152  public function assertLessThan(LimeTesterInterface $expected) 
    153153  { 
    154     throw new LimeTesterException($this, $expected); 
     154    throw new LimeAssertionFailedException($this, $expected); 
    155155  } 
    156156 
    157157  public function assertLessThanOrEqual(LimeTesterInterface $expected) 
    158158  { 
    159     throw new LimeTesterException($this, $expected); 
     159    throw new LimeAssertionFailedException($this, $expected); 
    160160  } 
    161161 
    162162  public function assertContains(LimeTesterInterface $expected) 
    163163  { 
    164     throw new LimeTesterException($this, $expected); 
     164    throw new LimeAssertionFailedException($this, $expected); 
    165165  } 
    166166 
    167167  public function assertNotContains(LimeTesterInterface $expected) 
    168168  { 
    169     throw new LimeTesterException($this, $expected); 
     169    throw new LimeAssertionFailedException($this, $expected); 
    170170  } 
    171171} 
  • tools/lime/branches/2.0-experimental/lib/tester/LimeTesterArray.php

    r20705 r20958  
    2929    if (!$expected instanceof LimeTesterArray || $this->getType() !== $expected->getType()) 
    3030    { 
    31       throw new LimeTesterException($this, $expected); 
     31      throw new LimeAssertionFailedException($this, $expected); 
    3232    } 
    3333 
     
    3838      if (!array_key_exists($key, $remaining)) 
    3939      { 
    40         throw new LimeTesterException($this, $expected->dumpExcerpt($key, $value)); 
     40        throw new LimeAssertionFailedException($this, $expected->dumpExcerpt($key, $value)); 
    4141      } 
    4242 
     
    4545        $remaining[$key]->assertEquals($value); 
    4646      } 
    47       catch (LimeTesterException $e) 
    48       { 
    49         throw new LimeTesterException($this->dumpExcerpt($key, $e->getActual()), $expected->dumpExcerpt($key, $e->getExpected())); 
     47      catch (LimeAssertionFailedException $e) 
     48      { 
     49        throw new LimeAssertionFailedException($this->dumpExcerpt($key, $e->getActual()), $expected->dumpExcerpt($key, $e->getExpected())); 
    5050      } 
    5151 
     
    5555    foreach ($remaining as $key => $value) 
    5656    { 
    57       throw new LimeTesterException($this->dumpExcerpt($key, $value), $expected); 
     57      throw new LimeAssertionFailedException($this->dumpExcerpt($key, $value), $expected); 
    5858    } 
    5959  } 
     
    7777        $this->value[$key]->assertNotEquals($value); 
    7878      } 
    79       catch (LimeTesterException $e) 
    80       { 
    81         throw new LimeTesterException($this, $expected); 
     79      catch (LimeAssertionFailedException $e) 
     80      { 
     81        throw new LimeAssertionFailedException($this, $expected); 
    8282      } 
    8383    } 
     
    8888    if (!$expected instanceof LimeTesterArray || $this->getType() !== $expected->getType()) 
    8989    { 
    90       throw new LimeTesterException($this, $expected); 
     90      throw new LimeAssertionFailedException($this, $expected); 
    9191    } 
    9292 
     
    9797      if (current($this->value) === false) 
    9898      { 
    99         throw new LimeTesterException($this, $expected->dumpExcerpt($key, $value)); 
     99        throw new LimeAssertionFailedException($this, $expected->dumpExcerpt($key, $value)); 
    100100      } 
    101101 
    102102      if ($key != key($this->value)) 
    103103      { 
    104         throw new LimeTesterException($this->dumpExcerpt(key($this->value), current($this->value)), $expected->dumpExcerpt($key, $value)); 
     104        throw new LimeAssertionFailedException($this->dumpExcerpt(key($this->value), current($this->value)), $expected->dumpExcerpt($key, $value)); 
    105105      } 
    106106 
     
    109109        current($this->value)->assertSame($value); 
    110110      } 
    111       catch (LimeTesterException $e) 
    112       { 
    113         throw new LimeTesterException($this->dumpExcerpt($key, $e->getActual()), $expected->dumpExcerpt($key, $e->getExpected())); 
     111      catch (LimeAssertionFailedException $e) 
     112      { 
     113        throw new LimeAssertionFailedException($this->dumpExcerpt($key, $e->getActual()), $expected->dumpExcerpt($key, $e->getExpected())); 
    114114      } 
    115115 
     
    119119    if (current($this->value) !== false) 
    120120    { 
    121       throw new LimeTesterException($this->dumpExcerpt(key($this->value), current($this->value)), $expected); 
     121      throw new LimeAssertionFailedException($this->dumpExcerpt(key($this->value), current($this->value)), $expected); 
    122122    } 
    123123  } 
     
    143143        current($this->value)->assertNotSame($value); 
    144144      } 
    145       catch (LimeTesterException $e) 
    146       { 
    147         throw new LimeTesterException($this->dumpExcerpt($key, $e->getActual()), $expected->dumpExcerpt($key, $e->getExpected())); 
     145      catch (LimeAssertionFailedException $e) 
     146      { 
     147        throw new LimeAssertionFailedException($this->dumpExcerpt($key, $e->getActual()), $expected->dumpExcerpt($key, $e->getExpected())); 
    148148      } 
    149149 
     
    161161        return; 
    162162      } 
    163       catch (LimeTesterException $e) 
    164       { 
    165       } 
    166     } 
    167  
    168     throw new LimeTesterException($this->dumpAll(), $expected); 
     163      catch (LimeAssertionFailedException $e) 
     164      { 
     165      } 
     166    } 
     167 
     168    throw new LimeAssertionFailedException($this->dumpAll(), $expected); 
    169169  } 
    170170 
     
    179179        $value->assertEquals($expected); 
    180180      } 
    181       catch (LimeTesterException $e) 
     181      catch (LimeAssertionFailedException $e) 
    182182      { 
    183183        $equal = false; 
     
    186186      if ($equal) 
    187187      { 
    188         throw new LimeTesterException($this->dumpAll(), $expected); 
     188        throw new LimeAssertionFailedException($this->dumpAll(), $expected); 
    189189      } 
    190190    } 
  • tools/lime/branches/2.0-experimental/lib/tester/LimeTesterDouble.php

    r20701 r20958  
    3939    if (abs($this->value - $expected->value) >= self::EPSILON) 
    4040    { 
    41       throw new LimeTesterException($this, $expected); 
     41      throw new LimeAssertionFailedException($this, $expected); 
    4242    } 
    4343  } 
     
    4747    if (abs($this->value - $expected->value) < self::EPSILON) 
    4848    { 
    49       throw new LimeTesterException($this, $expected); 
     49      throw new LimeAssertionFailedException($this, $expected); 
    5050    } 
    5151  } 
     
    5757    if (gettype($this->value) != gettype($expected->value)) 
    5858    { 
    59       throw new LimeTesterException($this, $expected); 
     59      throw new LimeAssertionFailedException($this, $expected); 
    6060    } 
    6161  } 
     
    6767      $this->assertEquals($expected); 
    6868    } 
    69     catch (LimeTesterException $e) 
     69    catch (LimeAssertionFailedException $e) 
    7070    { 
    7171      if (gettype($this->value) == gettype($expected->value)) 
  • tools/lime/branches/2.0-experimental/lib/tester/LimeTesterObject.php

    r20705 r20958  
    6464    if ($this->object !== $expected->object) 
    6565    { 
    66       throw new LimeTesterException($this, $expected); 
     66      throw new LimeAssertionFailedException($this, $expected); 
    6767    } 
    6868 
     
    7474    if ($this->object === $expected->object) 
    7575    { 
    76       throw new LimeTesterException($this, $expected); 
     76      throw new LimeAssertionFailedException($this, $expected); 
    7777    } 
    7878  } 
  • tools/lime/branches/2.0-experimental/lib/tester/LimeTesterResource.php

    r20702 r20958  
    1919    if ($this->value != $expected->value) 
    2020    { 
    21       throw new LimeTesterException($this, $expected); 
     21      throw new LimeAssertionFailedException($this, $expected); 
    2222    } 
    2323  } 
     
    2727    if ($this->value == $expected->value) 
    2828    { 
    29       throw new LimeTesterException($this, $expected); 
     29      throw new LimeAssertionFailedException($this, $expected); 
    3030    } 
    3131  } 
  • tools/lime/branches/2.0-experimental/lib/tester/LimeTesterScalar.php

    r20701 r20958  
    4747    if (!$this->equals($expected)) 
    4848    { 
    49       throw new LimeTesterException($this, $expected); 
     49      throw new LimeAssertionFailedException($this, $expected); 
    5050    } 
    5151  } 
     
    5555    if ($this->value !== $expected->value) 
    5656    { 
    57       throw new LimeTesterException($this, $expected); 
     57      throw new LimeAssertionFailedException($this, $expected); 
    5858    } 
    5959  } 
     
    6363    if ($this->equals($expected)) 
    6464    { 
    65       throw new LimeTesterException($this, $expected); 
     65      throw new LimeAssertionFailedException($this, $expected); 
    6666    } 
    6767  } 
     
    7171    if ($this->value === $expected->value) 
    7272    { 
    73       throw new LimeTesterException($this, $expected); 
     73      throw new LimeAssertionFailedException($this, $expected); 
    7474    } 
    7575  } 
     
    7979    if ($this->value <= $expected->value) 
    8080    { 
    81       throw new LimeTesterException($this, $expected); 
     81      throw new LimeAssertionFailedException($this, $expected); 
    8282    } 
    8383  } 
     
    8787    if ($this->value < $expected->value) 
    8888    { 
    89       throw new LimeTesterException($this, $expected); 
     89      throw new LimeAssertionFailedException($this, $expected); 
    9090    } 
    9191  } 
     
    9595    if ($this->value > $expected->value) 
    9696    { 
    97       throw new LimeTesterException($this, $expected); 
     97      throw new LimeAssertionFailedException($this, $expected); 
    9898    } 
    9999  } 
     
    103103    if ($this->value >= $expected->value) 
    104104    { 
    105       throw new LimeTesterException($this, $expected); 
     105      throw new LimeAssertionFailedException($this, $expected); 
    106106    } 
    107107  } 
  • tools/lime/branches/2.0-experimental/lib/tester/LimeTesterString.php

    r20701 r20958  
    2424    if (!preg_match($expected->value, $this->value)) 
    2525    { 
    26       throw new LimeTesterException($this, $expected); 
     26      throw new LimeAssertionFailedException($this, $expected); 
    2727    } 
    2828  } 
     
    3232    if (preg_match($expected->value, $this->value)) 
    3333    { 
    34       throw new LimeTesterException($this, $expected); 
     34      throw new LimeAssertionFailedException($this, $expected); 
    3535    } 
    3636  } 
  • tools/lime/branches/2.0-experimental/test/unit/tester/LimeTesterArrayTest.php

    r20705 r20958  
    2323  $expected = new LimeTesterScalar(false); 
    2424  // test 
    25   $t->expect('LimeTesterException'); 
     25  $t->expect('LimeAssertionFailedException'); 
    2626  $actual->assertEquals($expected); 
    2727 
     
    3333  $expected = new LimeTesterObject(new stdClass()); 
    3434  // test 
    35   $t->expect('LimeTesterException'); 
     35  $t->expect('LimeAssertionFailedException'); 
    3636  $actual->assertEquals($expected); 
    3737 
     
    4343  $expected = new LimeTesterArray(array(0 => 1)); 
    4444  // test 
    45   $t->expect('LimeTesterException'); 
     45  $t->expect('LimeAssertionFailedException'); 
    4646  $actual->assertEquals($expected); 
    4747 
     
    5353  $expected = new LimeTesterArray(array()); 
    5454  // test 
    55   $t->expect('LimeTesterException'); 
     55  $t->expect('LimeAssertionFailedException'); 
    5656  $actual->assertEquals($expected); 
    5757 
     
    6363  $expected = new LimeTesterArray(array(0 => 2)); 
    6464  // test 
    65   $t->expect('LimeTesterException'); 
     65  $t->expect('LimeAssertionFailedException'); 
    6666  $actual->assertEquals($expected); 
    6767 
     
    7373  $expected = new LimeTesterArray(array('b' => 2, 'a' => 1)); 
    7474  // test 
    75   $t->expect('LimeTesterException'); 
     75  $t->expect('LimeAssertionFailedException'); 
    7676  $actual->assertSame($expected); 
    7777 
     
    110110  $expected = new LimeTesterArray(array(0 => 1)); 
    111111  // test 
    112   $t->expect('LimeTesterException'); 
     112  $t->expect('LimeAssertionFailedException'); 
    113113  $actual->assertNotEquals($expected); 
    114114 
     
    120120  $expected = new LimeTesterScalar(false); 
    121121  // test 
    122   $t->expect('LimeTesterException'); 
     122  $t->expect('LimeAssertionFailedException'); 
    123123  $actual->assertSame($expected); 
    124124 
     
    130130  $expected = new LimeTesterObject(new stdClass()); 
    131131  // test 
    132   $t->expect('LimeTesterException'); 
     132  $t->expect('LimeAssertionFailedException'); 
    133133  $actual->assertSame($expected); 
    134134 
     
    140140  $expected = new LimeTesterArray(array(0 => 1)); 
    141141  // test 
    142   $t->expect('LimeTesterException'); 
     142  $t->expect('LimeAssertionFailedException'); 
    143143  $actual->assertSame($expected); 
    144144 
     
    150150  $expected = new LimeTesterArray(array()); 
    151151  // test 
    152   $t->expect('LimeTesterException'); 
     152  $t->expect('LimeAssertionFailedException'); 
    153153  $actual->assertSame($expected); 
    154154 
     
    160160  $expected = new LimeTesterArray(array('1')); 
    161161  // test 
    162   $t->expect('LimeTesterException'); 
     162  $t->expect('LimeAssertionFailedException'); 
    163163  $actual->assertSame($expected); 
    164164 
     
    170170  $expected = new LimeTesterArray(array('b' => 2, 'a' => 1)); 
    171171  // test 
    172   $t->expect('LimeTesterException'); 
     172  $t->expect('LimeAssertionFailedException'); 
    173173  $actual->assertSame($expected); 
    174174 
     
    207207  $expected = new LimeTesterArray(array(0 => 1)); 
    208208  // test 
    209   $t->expect('LimeTesterException'); 
     209  $t->expect('LimeAssertionFailedException'); 
    210210  $actual->assertNotSame($expected); 
    211211 
     
    235235  $expected = LimeTester::create(0); 
    236236  // test 
    237   $t->expect('LimeTesterException'); 
     237  $t->expect('LimeAssertionFailedException'); 
    238238  $actual->assertContains($expected); 
    239239 
     
    254254  $expected = LimeTester::create(1); 
    255255  // test 
    256   $t->expect('LimeTesterException'); 
     256  $t->expect('LimeAssertionFailedException'); 
    257257  $actual->assertNotContains($expected); 
    258258 
  • tools/lime/branches/2.0-experimental/test/unit/tester/LimeTesterDoubleTest.php

    r20701 r20958  
    3838  $expected = new LimeTesterString('1.0'); 
    3939  // test 
    40   $t->expect('LimeTesterException'); 
     40  $t->expect('LimeAssertionFailedException'); 
    4141  $actual->assertSame($expected); 
    4242 
     
    4848  $expected = new LimeTesterDouble(1 - 2/3); 
    4949  // test 
    50   $t->expect('LimeTesterException'); 
     50  $t->expect('LimeAssertionFailedException'); 
    5151  $actual->assertNotEquals($expected); 
    5252 
  • tools/lime/branches/2.0-experimental/test/unit/tester/LimeTesterIntegerTest.php

    r20701 r20958  
    2323  $expected = new LimeTesterInteger(1); 
    2424  // test 
    25   $t->expect('LimeTesterException'); 
     25  $t->expect('LimeAssertionFailedException'); 
    2626  $actual->assertGreaterThan($expected); 
    2727 
     
    3333  $expected = new LimeTesterInteger(2); 
    3434  // test 
    35   $t->expect('LimeTesterException'); 
     35  $t->expect('LimeAssertionFailedException'); 
    3636  $actual->assertGreaterThan($expected); 
    3737 
     
    4343  $expected = new LimeTesterInteger(2); 
    4444  // test 
    45   $t->expect('LimeTesterException'); 
     45  $t->expect('LimeAssertionFailedException'); 
    4646  $actual->assertGreaterThanOrEqual($expected); 
    4747 
     
    5353  $expected = new LimeTesterInteger(1); 
    5454  // test 
    55   $t->expect('LimeTesterException'); 
     55  $t->expect('LimeAssertionFailedException'); 
    5656  $actual->assertLessThanOrEqual($expected); 
    5757 
     
    6363  $expected = new LimeTesterInteger(1); 
    6464  // test 
    65   $t->expect('LimeTesterException'); 
     65  $t->expect('LimeAssertionFailedException'); 
    6666  $actual->assertLessThan($expected); 
    6767 
     
    7373  $expected = new LimeTesterInteger(1); 
    7474  // test 
    75   $t->expect('LimeTesterException'); 
     75  $t->expect('LimeAssertionFailedException'); 
    7676  $actual->assertLessThan($expected); 
  • tools/lime/branches/2.0-experimental/test/unit/tester/LimeTesterObjectTest.php

    r20705 r20958  
    3535  $expected = new LimeTesterScalar(false); 
    3636  // test 
    37   $t->expect('LimeTesterException'); 
     37  $t->expect('LimeAssertionFailedException'); 
    3838  $actual->assertEquals($expected); 
    3939 
     
    4545  $expected = new LimeTesterObject(new TestClass(1)); 
    4646  // test 
    47   $t->expect('LimeTesterException'); 
     47  $t->expect('LimeAssertionFailedException'); 
    4848  $actual->assertEquals($expected); 
    4949 
     
    6464  $expected = new LimeTesterObject(new TestClass()); 
    6565  // test 
    66   $t->expect('LimeTesterException'); 
     66  $t->expect('LimeAssertionFailedException'); 
    6767  $actual->assertSame($expected); 
    6868 
     
    9393  $expected = new LimeTesterObject(new TestClass()); 
    9494  // test 
    95   $t->expect('LimeTesterException'); 
     95  $t->expect('LimeAssertionFailedException'); 
    9696  $actual->assertNotEquals($expected); 
    9797 
     
    104104  $expected = new LimeTesterObject($object); 
    105105  // test 
    106   $t->expect('LimeTesterException'); 
     106  $t->expect('LimeAssertionFailedException'); 
    107107  $actual->assertNotSame($expected); 
    108108 
  • tools/lime/branches/2.0-experimental/test/unit/tester/LimeTesterResourceTest.php

    r20702 r20958  
    4545  $actual = new LimeTesterResource($handle1); 
    4646  $expected = new LimeTesterResource($handle2); 
    47   $t->expect('LimeTesterException'); 
     47  $t->expect('LimeAssertionFailedException'); 
    4848  $actual->assertEquals($expected); 
    4949 
     
    6060  $actual = new LimeTesterResource($handle1); 
    6161  $expected = new LimeTesterResource($handle1); 
    62   $t->expect('LimeTesterException'); 
     62  $t->expect('LimeAssertionFailedException'); 
    6363  $actual->assertNotEquals($expected); 
    6464 
  • tools/lime/branches/2.0-experimental/test/unit/tester/LimeTesterScalarTest.php

    r20701 r20958  
    2323  $expected = new LimeTesterScalar('b'); 
    2424  // test 
    25   $t->expect('LimeTesterException'); 
     25  $t->expect('LimeAssertionFailedException'); 
    2626  $actual->assertEquals($expected); 
    2727 
     
    3434  $expected = new LimeTesterScalar('Foobar'); 
    3535  // test 
    36   $t->expect('LimeTesterException'); 
     36  $t->expect('LimeAssertionFailedException'); 
    3737  $actual->assertEquals($expected); 
    3838 
     
    5353  $expected = new LimeTesterScalar(0); 
    5454  // test 
    55   $t->expect('LimeTesterException'); 
     55  $t->expect('LimeAssertionFailedException'); 
    5656  $actual->assertSame($expected); 
    5757 
     
    6363  $expected = new LimeTesterScalar(1); 
    6464  // test 
    65   $t->expect('LimeTesterException'); 
     65  $t->expect('LimeAssertionFailedException'); 
    6666  $actual->assertNotEquals($expected); 
    6767 
  • tools/lime/branches/2.0-experimental/test/unit/tester/LimeTesterStringTest.php

    r20701 r20958  
    2929  $expected = new LimeTesterString('/\d/'); 
    3030  // test 
    31   $t->expect('LimeTesterException'); 
     31  $t->expect('LimeAssertionFailedException'); 
    3232  $actual->assertLike($expected); 
    3333 
     
    4848  $expected = new LimeTesterString('/\d/'); 
    4949  // test 
    50   $t->expect('LimeTesterException'); 
     50  $t->expect('LimeAssertionFailedException'); 
    5151  $actual->assertUnlike($expected); 
    5252