Merge raisesCondition() into raises() using EitherType.

src/utest/Assert.hx

@@ -8,6 +8,7 @@ import haxe.io.Bytes;
 import utest.Assertation;
 import haxe.PosInfos;
 import haxe.Constraints;
+import haxe.extern.EitherType;
 
 typedef PosException = #if (haxe >= version("4.2.0")) haxe.exceptions.PosException #else haxe.Exception #end;
 
@@ -658,83 +659,60 @@ class Assert {
    * ```
    * @param method A method that generates the exception.
    * @param type The type of the expected error. Defaults to any type (catch all).
+   * @param condition The callback which is called upon an exception. The assertion passes
+   *      if this callback returns `true`. Otherwise assertion fails. If `type` is specified, that
+   *      will have already been checked before the function is called. In JavaScript, you must
+   *      specify `type`.
    * @param msgNotThrown An optional error message used when the function fails to raise the expected
    *      exception. If not passed a default one will be used
    * @param msgWrongType An optional error message used when the function raises the exception but it is
    *      of a different type than the one expected. If not passed a default one will be used
-   * @param pos Code position where the Assert call has been executed. Don't fill it
-   * unless you know what you are doing.
-   */
-  public static function raises(method:() -> Void, ?type:Any, ?msgNotThrown : String , ?msgWrongType : String, ?pos : PosInfos) : Bool {
-    return _raisesImpl(method, type, _ -> true, msgNotThrown, msgWrongType, pos);
-  }
-
-  /**
-   * It is used to test an application that under certain circumstances must
-   * react throwing an error with specific characteristics checked in the `condition` callback.
-   * Simple condition check example:
-   * ```haxe
-   * Assert.raisesCondition(() -> throw new MyException('Hello, world!'), MyException, e -> e.message.indexOf('Hello') == 0);
-   * ```
-   * Complex condition check example:
-   * ```haxe
-   * Assert.raisesCondition(
-   *  () -> throw new MyException('Hello, world!'),
-   *  MyException, e -> {
-   *    Assert.equals(e.code, 10);
-   *    Assert.isTrue(e.message.length > 5);
-   *  }
-   * );
-   * ```
-   * @param method A method that generates the exception.
-   * @param type The type of the expected error.
-   * @param condition The callback which is called upon an exception of expected type. The assertion passes
-   *      if this callback returns `true`. Otherwise assertion fails.
-   * @param msgNotThrown An optional error message used when the function fails to raise the expected
-   *      exception. If not passed a default one will be used.
-   * @param msgWrongType An optional error message used when the function raises the exception but it is
-   *      of a different type than the one expected. If not passed a default one will be used.
    * @param msgWrongCondition An optional error message used when the `condition` callback returns `false`
    * @param pos Code position where the Assert call has been executed. Don't fill it
    * unless you know what you are doing.
    */
-  public static function raisesCondition<T>(method:() -> Void, type:Class<T>, condition:(e:T)->Bool, ?msgNotThrown : String , ?msgWrongType : String, ?msgWrongCondition : String, ?pos : PosInfos) : Bool {
-    var cond = e -> {
-      if(null == msgWrongCondition)
-        msgWrongCondition = 'exception of ${Type.getClassName(type)} is raised, but condition failed';
-      isTrue(condition(e), msgWrongCondition, pos);
+  public static function raises<T>(method:() -> Void, ?type:EitherType<Class<T>, Any>, #if (haxe_ver >= 4.2) ?condition:(e:T)->Bool, #end ?msgNotThrown : String , ?msgWrongType : String, #if (haxe_ver >= 4.2) ?msgWrongCondition : String, #end ?pos : PosInfos) : Bool {
+    #if (!js && (haxe_ver >= 4.2))
+    if(Reflect.isFunction(type)) {
+      condition = (type:Any);
+      type = null;
     }
-    return _raisesImpl(method, type, cond, msgNotThrown, msgWrongType, pos);
-  }
-
-  static function _raisesImpl(method:() -> Void, type:Any, condition : (Dynamic)->Bool, msgNotThrown : String , msgWrongType : String, pos : PosInfos) {
-    var typeDescr = "of type " + Type.getClassName(type);
-    inline function handleCatch(ex:Any):Bool {
+    #end
+    var typeDescr = type != null ? "exception of type " + Type.getClassName(type) : "exception";
+    try {
+      method();
+    // Broken on eval in Haxe 4.3.2: https://github.com/HaxeFoundation/haxe/issues/11321
+    // } catch(ex:ValueException) {
+    //   return handleCatch(ex.value);
+    } catch (ex) {
+      var ex = Std.isOfType(ex, ValueException) ? (cast ex:ValueException).value : (ex:Any);
+      inline function checkCondition():Bool {
+        #if (haxe_ver >= 4.2)
+        return if(null == condition) {
+          pass(pos);
+        } else {
+          if(null == msgWrongCondition)
+            msgWrongCondition = '$typeDescr is raised, but condition failed';
+          isTrue(condition(cast ex), msgWrongCondition, pos);
+        }
+        #else
+        return pass(pos);
+        #end
+      }
       return if(null == type) {
-        pass(pos);
+        checkCondition();
       } else {
         if (null == msgWrongType)
-          msgWrongType = "expected throw " + typeDescr + " but it is "  + ex;
+          msgWrongType = "expected " + typeDescr + " but it is "  + ex;
         if(isTrue(Std.isOfType(ex, type), msgWrongType, pos)) {
-          condition(ex);
+          checkCondition();
         } else {
           false;
         }
       }
     }
-    try {
-      method();
-    // Broken on eval in Haxe 4.3.2: https://github.com/HaxeFoundation/haxe/issues/11321
-    // } catch(ex:ValueException) {
-    //   return handleCatch(ex.value);
-    } catch (ex) {
-      if(Std.isOfType(ex, ValueException)) {
-        return handleCatch((cast ex:ValueException).value);
-      }
-      return handleCatch(ex);
-    }
     if (null == msgNotThrown)
-      msgNotThrown = "exception " + typeDescr + " not raised";
+      msgNotThrown = typeDescr + " not raised";
     return fail(msgNotThrown, pos);
   }
 

test/utest/TestAssert.hx

@@ -106,12 +106,14 @@ class TestAssert extends Test {
       }
   }
 
+  #if (haxe_ver >= 4.2)
   public function testRaisesCondition() {
-    success(() -> raisesCondition(() -> throw new SampleException('haxe.Exception-based'), SampleException, e -> e.message.indexOf('haxe') >= 0));
-    failure(() -> raisesCondition(() -> throw new SampleException('haxe.Exception-based'), SampleException, e -> e.message == 'fail'));
-    success(() -> raisesCondition(() -> throw 'Non-haxe.Exception', String, e -> e.indexOf('haxe') >= 0));
-    failure(() -> raisesCondition(() -> throw 'Non-haxe.Exception', String, e -> e == 'fail'));
+    success(() -> raises(() -> throw new SampleException('haxe.Exception-based'), SampleException, e -> e.message.indexOf('haxe') >= 0));
+    failure(() -> raises(() -> throw new SampleException('haxe.Exception-based'), SampleException, e -> e.message == 'fail'));
+    success(() -> raises(() -> throw 'Non-haxe.Exception', String, e -> e.indexOf('haxe') >= 0));
+    failure(() -> raises(() -> throw 'Non-haxe.Exception', String, e -> e == 'fail'));
   }
+  #end
 
   public function testIs() {
     var values : Array<Any> = ["str",    1,   0.1,   new TestAssert(), {},      [1]];