10
20
30
40
50
60
70
80
90
100
110
120
130
140
150
160
170
180
190
200
210
220
23141
240
25141
260
27141
28141
290
30141
31232
320
33109
3418
3518
360
370
380
390
400
410
4278
430
4432
4515
460
4715
487
490
500
5115
520
5315
540
5515
568
570
580
590
608
610
627
630
640
650
667
670
680
6915
7015
710
7215
730
740
750
760
770
780
790
80141
810
820
830
840
85126
860
87126
880
89126
90126
910
92126
93453
940
9569
9631
9731
980
990
1000
1010
1020
1030
104372
1050
10657
10728
10828
1090
1100
1110
1120
1130
1140
1150
116126
1170
1180
1190
1200
121124
1220
123124
1240
125124
126124
1270
128124
1290
130124
131124
132124
1330
1340
135124
136124
137124
1380
1390
1400
1410
1420
1430
144124
145124
1460
147124
1483
1490
1500
151124
15260
1530
1540
155124
156155
1570
15865
15920
1600
1610
1620
1630
1640
16520
1660
1670
1680
1690
1700
1710
17297
1730
17459
17519
1760
1770
1780
1790
1800
1810
1820
183124
1840
1850
1860
1870
18849
1890
19049
19128
1920
1930
1940
19528
1960
1970
19821
1990
2000
2010
2020
20321
2040
2050
20649
20749
2080
2090
2100
2110
21276
2130
21431
2150
2160
2170
2180
21928
2200
22128
22214
2230
2240
2250
22614
2270
22814
2290
2300
2310
2320
23314
2340
2350
23628
23728
2380
2390
2400
2410
24270
2430
24428
2450
2460
2470
24849
2490
25049
25122
2520
2530
25449
2550
25649
2570
2580
2590
2600
26177
2620
26331
2640
2650
2660
26728
2680
26928
27015
2710
2720
27328
2740
27528
2760
2770
2780
2790
28071
2810
28228
2830
2840
2850
286156
2870
2880
289156
2900
291156
292131
2930
2940
2950
296156
2970
2980
2990
300391
3010
3020
module fluentasserts.core.operations.contain;
import std.algorithm;
import std.array;
import std.conv;
import fluentasserts.core.array;
import fluentasserts.core.results;
import fluentasserts.core.evaluation;
import fluentasserts.core.serializers;
import fluentasserts.core.lifecycle;
version(unittest) {
import fluentasserts.core.expect;
}
static immutable containDescription = "When the tested value is a string, it asserts that the given string val is a substring of the target. \n\n" ~
"When the tested value is an array, it asserts that the given val is inside the tested value.";
///
IResult[] contain(ref Evaluation evaluation) @safe nothrow {
evaluation.message.addText(".");
IResult[] results = [];
auto expectedPieces = evaluation.expectedValue.strValue.parseList.cleanString;
auto testData = evaluation.currentValue.strValue.cleanString;
if(!evaluation.isNegated) {
auto missingValues = expectedPieces.filter!(a => !testData.canFind(a)).array;
if(missingValues.length > 0) {
addLifecycleMessage(evaluation, missingValues);
try results ~= new ExpectedActualResult(createResultMessage(evaluation.expectedValue, expectedPieces), testData);
catch(Exception e) {
results ~= e.toResults;
return results;
}
}
} else {
auto presentValues = expectedPieces.filter!(a => testData.canFind(a)).array;
if(presentValues.length > 0) {
string message = "to not contain ";
if(presentValues.length > 1) {
message ~= "any ";
}
message ~= evaluation.expectedValue.strValue;
evaluation.message.addText(" ");
if(presentValues.length == 1) {
try evaluation.message.addValue(presentValues[0]); catch(Exception e) {
evaluation.message.addText(" some value ");
}
evaluation.message.addText(" is present in ");
} else {
try evaluation.message.addValue(presentValues.to!string); catch(Exception e) {
evaluation.message.addText(" some values ");
}
evaluation.message.addText(" are present in ");
}
evaluation.message.addValue(evaluation.currentValue.strValue);
evaluation.message.addText(".");
try results ~= new ExpectedActualResult(message, testData);
catch(Exception e) {
results ~= e.toResults;
return results;
}
}
}
return results;
}
///
IResult[] arrayContain(ref Evaluation evaluation) @trusted nothrow {
evaluation.message.addText(".");
IResult[] results = [];
auto expectedPieces = evaluation.expectedValue.proxyValue.toArray;
auto testData = evaluation.currentValue.proxyValue.toArray;
if(!evaluation.isNegated) {
auto missingValues = expectedPieces.filter!(a => testData.filter!(b => b.isEqualTo(a)).empty).array;
if(missingValues.length > 0) {
addLifecycleMessage(evaluation, missingValues);
try results ~= new ExpectedActualResult(createResultMessage(evaluation.expectedValue, expectedPieces), evaluation.currentValue.strValue);
catch(Exception e) {
results ~= e.toResults;
return results;
}
}
} else {
auto presentValues = expectedPieces.filter!(a => !testData.filter!(b => b.isEqualTo(a)).empty).array;
if(presentValues.length > 0) {
addNegatedLifecycleMessage(evaluation, presentValues);
try results ~= new ExpectedActualResult(createNegatedResultMessage(evaluation.expectedValue, expectedPieces), evaluation.currentValue.strValue);
catch(Exception e) {
results ~= e.toResults;
return results;
}
}
}
return results;
}
///
IResult[] arrayContainOnly(ref Evaluation evaluation) @safe nothrow {
evaluation.message.addText(".");
IResult[] results = [];
auto expectedPieces = evaluation.expectedValue.proxyValue.toArray;
auto testData = evaluation.currentValue.proxyValue.toArray;
auto comparison = ListComparison!EquableValue(testData, expectedPieces);
EquableValue[] missing;
EquableValue[] extra;
EquableValue[] common;
try {
missing = comparison.missing;
extra = comparison.extra;
common = comparison.common;
} catch(Exception e) {
results ~= e.toResults;
return results;
}
string strExtra = "";
string strMissing = "";
if(extra.length > 0) {
strExtra = extra.niceJoin(evaluation.currentValue.typeName);
}
if(missing.length > 0) {
strMissing = missing.niceJoin(evaluation.currentValue.typeName);
}
if(!evaluation.isNegated) {
auto isSuccess = missing.length == 0 && extra.length == 0 && common.length == testData.length;
if(!isSuccess) {
try results ~= new ExpectedActualResult("", testData.niceJoin(evaluation.currentValue.typeName));
catch(Exception e) {
results ~= e.toResults;
return results;
}
try results ~= new ExtraMissingResult(strExtra, strMissing);
catch(Exception e) {
results ~= e.toResults;
return results;
}
}
} else {
auto isSuccess = (missing.length != 0 || extra.length != 0) || common.length != testData.length;
if(!isSuccess) {
try results ~= new ExpectedActualResult("to not contain " ~ expectedPieces.niceJoin(evaluation.currentValue.typeName), testData.niceJoin(evaluation.currentValue.typeName));
catch(Exception e) {
results ~= e.toResults;
return results;
}
}
}
return results;
}
///
void addLifecycleMessage(ref Evaluation evaluation, string[] missingValues) @safe nothrow {
evaluation.message.addText(" ");
if(missingValues.length == 1) {
try evaluation.message.addValue(missingValues[0]); catch(Exception) {
evaluation.message.addText(" some value ");
}
evaluation.message.addText(" is missing from ");
} else {
try {
evaluation.message.addValue(missingValues.niceJoin(evaluation.currentValue.typeName));
} catch(Exception) {
evaluation.message.addText(" some values ");
}
evaluation.message.addText(" are missing from ");
}
evaluation.message.addValue(evaluation.currentValue.strValue);
evaluation.message.addText(".");
}
///
void addLifecycleMessage(ref Evaluation evaluation, EquableValue[] missingValues) @safe nothrow {
auto missing = missingValues.map!(a => a.getSerialized.cleanString).array;
addLifecycleMessage(evaluation, missing);
}
///
void addNegatedLifecycleMessage(ref Evaluation evaluation, string[] presentValues) @safe nothrow {
evaluation.message.addText(" ");
if(presentValues.length == 1) {
try evaluation.message.addValue(presentValues[0]); catch(Exception e) {
evaluation.message.addText(" some value ");
}
evaluation.message.addText(" is present in ");
} else {
try evaluation.message.addValue(presentValues.niceJoin(evaluation.currentValue.typeName));
catch(Exception e) {
evaluation.message.addText(" some values ");
}
evaluation.message.addText(" are present in ");
}
evaluation.message.addValue(evaluation.currentValue.strValue);
evaluation.message.addText(".");
}
///
void addNegatedLifecycleMessage(ref Evaluation evaluation, EquableValue[] missingValues) @safe nothrow {
auto missing = missingValues.map!(a => a.getSerialized).array;
addNegatedLifecycleMessage(evaluation, missing);
}
string createResultMessage(ValueEvaluation expectedValue, string[] expectedPieces) @safe nothrow {
string message = "to contain ";
if(expectedPieces.length > 1) {
message ~= "all ";
}
message ~= expectedValue.strValue;
return message;
}
///
string createResultMessage(ValueEvaluation expectedValue, EquableValue[] missingValues) @safe nothrow {
auto missing = missingValues.map!(a => a.getSerialized).array;
return createResultMessage(expectedValue, missing);
}
string createNegatedResultMessage(ValueEvaluation expectedValue, string[] expectedPieces) @safe nothrow {
string message = "to not contain ";
if(expectedPieces.length > 1) {
message ~= "any ";
}
message ~= expectedValue.strValue;
return message;
}
///
string createNegatedResultMessage(ValueEvaluation expectedValue, EquableValue[] missingValues) @safe nothrow {
auto missing = missingValues.map!(a => a.getSerialized).array;
return createNegatedResultMessage(expectedValue, missing);
}
string niceJoin(string[] values, string typeName = "") @safe nothrow {
string result = "";
try {
result = values.to!string;
if(!typeName.canFind("string")) {
result = result.replace(`"`, "");
}
} catch(Exception) {}
return result;
}
string niceJoin(EquableValue[] values, string typeName = "") @safe nothrow {
return values.map!(a => a.getSerialized.cleanString).array.niceJoin(typeName);
}