10
20
30
40
50
60
70
80
90
100
110
120
130
140
150
160
170
186
196
200
210
220
230
240
250
2645
270
2845
2945
300
3155
323
333
340
353
363
373
383
393
400
413
420
430
4480
454
460
474
480
490
5062
511
521
530
541
550
561
570
580
5945
6045
610
6245
630
640
650
660
670
682
690
700
710
720
731
740
751
760
770
782
790
801
810
821
831
841
850
860
871
880
890
900
910
921
932
940
950
960
970
981
990
1001
1010
1020
1032
1040
1051
1060
1071
1081
1091
1101
1110
1120
1131
1140
1150
1160
1170
1181
1192
1200
1210
1220
12324
1240
12524
1260
1270
12848
1290
1300
1310
1320
1330
1340
1350
1360
1370
1380
1390
1400
14124
1420
1430
1440
1450
1460
14772
1480
1490
1500
1510
1520
1530
1540
1550
15624
15724
1580
15924
1600
1610
1620
1630
164481
1650
166481
1670
168481
169481
1700
1710
172481
173481
1740
175960
1761
1771
1780
1791
1801
1811
1821
1831
1840
1851
1860
1870
1881433
1891
1901
1910
1921
1931
1941
1951
1961
1970
1981
1990
2000
201481
202481
2030
204481
2050
2060
2070
2080
2091
2101
2110
2120
2130
2140
2150
2161
2170
2180
2191
2201
2210
2220
2231
2240
2251
2261
2271
2281
2290
2300
2311
2320
2330
2340
2350
2361
2371
2380
2390
2400
2410
2420
2431
2440
2450
2461
2471
2480
2490
2501
2511
2521
2531
2541
2550
2560
2571
2580
2590
2600
2610
2620
2630
2640
2658
2660
2678
2688
2698
2700
2718
2728
2730
2740
2758
2768
2770
2780
2798
2808
2818
2828
2830
2848
2856
2860
2870
28810
2891
2900
2911
2920
2930
29418
2952
2962
2972
2982
2992
3000
3012
3020
3030
30420
3051
3061
3071
3081
3091
3100
3111
3120
3130
3148
3150
3160
3170
3180
3191
3200
3210
3221
3230
3241
3250
3260
3271
3282
3290
3300
3310
3320
3331
3340
3350
3361
3370
3380
3390
3400
3411
3420
3430
3440
3450
3461
3470
3480
3491
3501
3510
3520
3531
3540
3550
3561
3572
3580
3590
3600
3610
3621
3630
3640
3651
3661
3670
3680
3690
3700
3710
3721
3730
3740
3750
3760
3771
3780
3790
3801
3811
3820
3830
3841
3850
3860
3871
3882
3890
3900
3910
3920
3931
3940
3950
3961
3971
3980
3990
4000
4010
4020
4031
4040
module fluentasserts.core.operations.throwable;
public import fluentasserts.core.base;
import fluentasserts.core.results;
import fluentasserts.core.lifecycle;
import fluentasserts.core.expect;
import fluentasserts.core.serializers;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
static immutable throwAnyDescription = "Tests that the tested callable throws an exception.";
version(unittest) {
class CustomException : Exception {
this(string msg, string fileName = "", size_t line = 0, Throwable next = null) {
super(msg, fileName, line, next);
}
}
}
///
IResult[] throwAnyException(ref Evaluation evaluation) @trusted nothrow {
IResult[] results;
evaluation.message.addText(". ");
auto thrown = evaluation.currentValue.throwable;
if(evaluation.currentValue.throwable && evaluation.isNegated) {
string message;
try message = thrown.message.to!string; catch(Exception) {}
evaluation.message.addText("`");
evaluation.message.addValue(thrown.classinfo.name);
evaluation.message.addText("` saying `");
evaluation.message.addValue(message);
evaluation.message.addText("` was thrown.");
try results ~= new ExpectedActualResult("No exception to be thrown", "`" ~ thrown.classinfo.name ~ "` saying `" ~ message ~ "`"); catch(Exception) {}
}
if(!thrown && !evaluation.isNegated) {
evaluation.message.addText("No exception was thrown.");
try results ~= new ExpectedActualResult("Any exception to be thrown", "Nothing was thrown"); catch(Exception) {}
}
if(thrown && !evaluation.isNegated && "Throwable" in evaluation.currentValue.meta) {
string message;
try message = thrown.message.to!string; catch(Exception) {}
evaluation.message.addText("A `Throwable` saying `" ~ message ~ "` was thrown.");
try results ~= new ExpectedActualResult("Any exception to be thrown", "A `Throwable` with message `" ~ message ~ "` was thrown"); catch(Exception) {}
}
evaluation.throwable = thrown;
evaluation.currentValue.throwable = null;
return results;
}
/// It should be successfull when the function does not throw
unittest {
void test() {}
expect({ test(); }).to.not.throwAnyException();
}
/// It should fail when an exception is thrown and none is expected
unittest {
void test() { throw new Exception("Test exception"); }
bool thrown;
try {
expect({ test(); }).to.not.throwAnyException();
} catch(TestException e) {
thrown = true;
assert(e.message.indexOf("should not throw any exception. `object.Exception` saying `Test exception` was thrown.") != -1);
assert(e.message.indexOf("\n Expected:No exception to be thrown\n") != -1);
assert(e.message.indexOf("\n Actual:`object.Exception` saying `Test exception`\n") != -1);
}
assert(thrown, "The exception was not thrown");
}
/// It should be successfull when the function throws an expected exception
unittest {
void test() { throw new Exception("test"); }
expect({ test(); }).to.throwAnyException;
}
/// It should not be successfull when the function throws a throwable and an exception is expected
unittest {
void test() { assert(false); }
bool thrown;
try {
expect({ test(); }).to.throwAnyException;
} catch(TestException e) {
thrown = true;
assert(e.message.indexOf("should throw any exception. A `Throwable` saying `Assertion failure` was thrown.") != -1);
assert(e.message.indexOf("\n Expected:Any exception to be thrown\n") != -1);
assert(e.message.indexOf("\n Actual:A `Throwable` with message `Assertion failure` was thrown\n") != -1);
assert(e.file == "source/fluentasserts/core/operations/throwable.d");
}
assert(thrown, "The exception was not thrown");
}
/// It should be successfull when the function throws an expected exception
unittest {
void test() { throw new Exception("test"); }
expect({ test(); }).to.throwAnyException;
}
IResult[] throwAnyExceptionWithMessage(ref Evaluation evaluation) @trusted nothrow {
IResult[] results;
auto thrown = evaluation.currentValue.throwable;
if(thrown !is null && evaluation.isNegated) {
string message;
try message = thrown.message.to!string; catch(Exception) {}
evaluation.message.addText("`");
evaluation.message.addValue(thrown.classinfo.name);
evaluation.message.addText("` saying `");
evaluation.message.addValue(message);
evaluation.message.addText("` was thrown.");
try results ~= new ExpectedActualResult("No exception to be thrown", "`" ~ thrown.classinfo.name ~ "` saying `" ~ message ~ "`"); catch(Exception) {}
}
if(thrown is null && !evaluation.isNegated) {
evaluation.message.addText("Nothing was thrown.");
try results ~= new ExpectedActualResult("Any exception to be thrown", "Nothing was thrown"); catch(Exception) {}
}
if(thrown && !evaluation.isNegated && "Throwable" in evaluation.currentValue.meta) {
string message;
try message = thrown.message.to!string; catch(Exception) {}
evaluation.message.addText(". A `Throwable` saying `" ~ message ~ "` was thrown.");
try results ~= new ExpectedActualResult("Any throwable with the message `" ~ message ~ "` to be thrown", "A `" ~ thrown.classinfo.name ~ "` with message `" ~ message ~ "` was thrown"); catch(Exception) {}
}
evaluation.throwable = thrown;
evaluation.currentValue.throwable = null;
return results;
}
///
IResult[] throwException(ref Evaluation evaluation) @trusted nothrow {
evaluation.message.addText(".");
string exceptionType;
if("exceptionType" in evaluation.expectedValue.meta) {
exceptionType = evaluation.expectedValue.meta["exceptionType"].cleanString;
}
IResult[] results;
auto thrown = evaluation.currentValue.throwable;
if(thrown && evaluation.isNegated && thrown.classinfo.name == exceptionType) {
string message;
try message = thrown.message.to!string; catch(Exception) {}
evaluation.message.addText("`");
evaluation.message.addValue(thrown.classinfo.name);
evaluation.message.addText("` saying `");
evaluation.message.addValue(message);
evaluation.message.addText("` was thrown.");
try results ~= new ExpectedActualResult("no `" ~ exceptionType ~ "` to be thrown", "`" ~ thrown.classinfo.name ~ "` saying `" ~ message ~ "`"); catch(Exception) {}
}
if(thrown && !evaluation.isNegated && thrown.classinfo.name != exceptionType) {
string message;
try message = thrown.message.to!string; catch(Exception) {}
evaluation.message.addText("`");
evaluation.message.addValue(thrown.classinfo.name);
evaluation.message.addText("` saying `");
evaluation.message.addValue(message);
evaluation.message.addText("` was thrown.");
try results ~= new ExpectedActualResult(exceptionType, "`" ~ thrown.classinfo.name ~ "` saying `" ~ message ~ "`"); catch(Exception) {}
}
evaluation.throwable = thrown;
evaluation.currentValue.throwable = null;
return results;
}
/// Should be able to catch a certain exception type
unittest {
expect({
throw new CustomException("test");
}).to.throwException!CustomException;
}
/// It should fail when an unexpected exception is thrown
unittest {
bool thrown;
try {
expect({
throw new Exception("test");
}).to.throwException!CustomException;
} catch(TestException e) {
thrown = true;
assert(e.message.indexOf("should throw exception \"fluentasserts.core.operations.throwable.CustomException\".`object.Exception` saying `test` was thrown.") != -1);
assert(e.message.indexOf("\n Expected:fluentasserts.core.operations.throwable.CustomException\n") != -1);
assert(e.message.indexOf("\n Actual:`object.Exception` saying `test`\n") != -1);
assert(e.file == "source/fluentasserts/core/operations/throwable.d");
}
assert(thrown, "The exception was not thrown");
}
/// It should not fail when an exception is thrown and it is not expected
unittest {
expect({
throw new Exception("test");
}).to.not.throwException!CustomException;
}
/// It should fail when an different exception than the one checked is thrown
unittest {
bool thrown;
try {
expect({
throw new CustomException("test");
}).to.not.throwException!CustomException;
} catch(TestException e) {
thrown = true;
assert(e.message.indexOf("should not throw exception \"fluentasserts.core.operations.throwable.CustomException\".`fluentasserts.core.operations.throwable.CustomException` saying `test` was thrown.") != -1);
assert(e.message.indexOf("\n Expected:no `fluentasserts.core.operations.throwable.CustomException` to be thrown\n") != -1);
assert(e.message.indexOf("\n Actual:`fluentasserts.core.operations.throwable.CustomException` saying `test`\n") != -1);
assert(e.file == "source/fluentasserts/core/operations/throwable.d");
}
assert(thrown, "The exception was not thrown");
}
///
IResult[] throwExceptionWithMessage(ref Evaluation evaluation) @trusted nothrow {
import std.stdio;
evaluation.message.addText(". ");
string exceptionType;
string message;
string expectedMessage = evaluation.expectedValue.strValue;
if(expectedMessage.startsWith(`"`)) {
expectedMessage = expectedMessage[1..$-1];
}
if("exceptionType" in evaluation.expectedValue.meta) {
exceptionType = evaluation.expectedValue.meta["exceptionType"].cleanString;
}
IResult[] results;
auto thrown = evaluation.currentValue.throwable;
evaluation.throwable = thrown;
evaluation.currentValue.throwable = null;
if(thrown) {
try message = thrown.message.to!string; catch(Exception) {}
}
if(!thrown && !evaluation.isNegated) {
evaluation.message.addText("No exception was thrown.");
try results ~= new ExpectedActualResult("`" ~ exceptionType ~ "` with message `" ~ expectedMessage ~ "` to be thrown", "nothing was thrown"); catch(Exception) {}
}
if(thrown && !evaluation.isNegated && thrown.classinfo.name != exceptionType) {
evaluation.message.addText("`");
evaluation.message.addValue(thrown.classinfo.name);
evaluation.message.addText("` saying `");
evaluation.message.addValue(message);
evaluation.message.addText("` was thrown.");
try results ~= new ExpectedActualResult("`" ~ exceptionType ~ "` to be thrown", "`" ~ thrown.classinfo.name ~ "` saying `" ~ message ~ "`"); catch(Exception) {}
}
if(thrown && !evaluation.isNegated && thrown.classinfo.name == exceptionType && message != expectedMessage) {
evaluation.message.addText("`");
evaluation.message.addValue(thrown.classinfo.name);
evaluation.message.addText("` saying `");
evaluation.message.addValue(message);
evaluation.message.addText("` was thrown.");
try results ~= new ExpectedActualResult("`" ~ exceptionType ~ "` saying `" ~ message ~ "` to be thrown", "`" ~ thrown.classinfo.name ~ "` saying `" ~ message ~ "`"); catch(Exception) {}
}
return results;
}
/// It fails when an exception is not catched
unittest {
Exception exception;
try {
expect({}).to.throwException!Exception.withMessage.equal("test");
} catch(Exception e) {
exception = e;
}
assert(exception !is null);
expect(exception.message).to.contain(`should throw exception with message equal "test". No exception was thrown.`);
}
/// It does not fail when an exception is not expected and none is not catched
unittest {
Exception exception;
try {
expect({}).not.to.throwException!Exception.withMessage.equal("test");
} catch(Exception e) {
exception = e;
}
assert(exception is null);
}
/// It fails when the caught exception has a different type
unittest {
Exception exception;
try {
expect({
throw new CustomException("hello");
}).to.throwException!Exception.withMessage.equal("test");
} catch(Exception e) {
exception = e;
}
assert(exception !is null);
expect(exception.message).to.contain("should throw exception with message equal \"test\". `fluentasserts.core.operations.throwable.CustomException` saying `hello` was thrown.");
}
/// It does not fail when a certain exception type is not catched
unittest {
Exception exception;
try {
expect({
throw new CustomException("hello");
}).not.to.throwException!Exception.withMessage.equal("test");
} catch(Exception e) {
exception = e;
}
assert(exception is null);
}
/// It fails when the caught exception has a different message
unittest {
Exception exception;
try {
expect({
throw new CustomException("hello");
}).to.throwException!CustomException.withMessage.equal("test");
} catch(Exception e) {
exception = e;
}
assert(exception !is null);
expect(exception.message).to.contain("should throw exception with message equal \"test\". `fluentasserts.core.operations.throwable.CustomException` saying `hello` was thrown.");
}
/// It does not fails when the caught exception is expected to have a different message
unittest {
Exception exception;
try {
expect({
throw new CustomException("hello");
}).not.to.throwException!CustomException.withMessage.equal("test");
} catch(Exception e) {
exception = e;
}
assert(exception is null);
}