fluentasserts.core.operations.throwable 164/181(90%) line coverage

      
10
20
30
40
50
60
70
80
90
100
110
120
130
140
150
166
176
180
190
200
210
220
230
2441
250
2641
2741
280
2948
303
313
320
333
343
353
363
373
380
393
400
410
4275
433
440
453
460
470
4852
491
501
510
521
530
541
550
560
5741
5841
590
6041
610
620
630
640
650
662
670
680
690
700
711
720
731
740
750
762
770
781
790
801
811
821
830
840
851
860
870
880
890
901
912
920
930
940
950
961
970
981
990
1000
1012
1020
1031
1040
1051
1061
1071
1081
1090
1100
1111
1120
1130
1140
1150
1161
1172
1180
1190
1200
12123
1220
12323
1240
1250
12646
1270
1280
1290
1300
1310
1320
1330
1340
1350
1360
1370
1380
13923
1400
1410
1420
1430
1440
14569
1460
1470
1480
1490
1500
1510
1520
1530
15423
15523
1560
15723
1580
1590
1600
1610
162444
1630
164444
1650
166444
167444
1680
1690
170444
171444
1720
173886
1741
1751
1760
1771
1781
1791
1801
1811
1820
1831
1840
1850
1861322
1871
1881
1890
1901
1911
1921
1931
1941
1950
1961
1970
1980
199444
200444
2010
202444
2030
2040
2050
2060
2071
2081
2090
2100
2110
2120
2130
2141
2150
2160
2171
2181
2190
2200
2211
2220
2231
2241
2251
2261
2270
2280
2291
2300
2310
2320
2330
2341
2351
2360
2370
2380
2390
2400
2411
2420
2430
2441
2451
2460
2470
2481
2491
2501
2511
2521
2530
2540
2551
2560
2570
2580
2590
2600
2610
2620
2638
2640
2658
2668
2678
2680
2698
2708
2710
2720
2738
2748
2750
2760
2778
2788
2798
2808
2810
2828
2836
2840
2850
28610
2871
2880
2891
2900
2910
29218
2932
2942
2952
2962
2972
2980
2992
3000
3010
30220
3031
3041
3051
3061
3071
3080
3091
3100
3110
3128
3130
3140
3150
3160
3171
3180
3190
3201
3210
3221
3230
3240
3251
3262
3270
3280
3290
3300
3311
3320
3330
3341
3350
3360
3370
3380
3391
3400
3410
3420
3430
3441
3450
3460
3471
3481
3490
3500
3511
3520
3530
3541
3552
3560
3570
3580
3590
3601
3610
3620
3631
3641
3650
3660
3670
3680
3690
3701
3710
3720
3730
3740
3751
3760
3770
3781
3791
3800
3810
3821
3830
3840
3851
3862
3870
3880
3890
3900
3911
3920
3930
3941
3951
3960
3970
3980
3990
4000
4011
4020
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; 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); }