From e49e97013e87fbdd5df479b6000f0ac4e3b01737 Mon Sep 17 00:00:00 2001 From: Szabo Bogdan Date: Sat, 3 Apr 2021 17:29:40 +0200 Subject: [PATCH] add the greaterOrEqualTo operation --- source/fluentasserts/core/expect.d | 10 ++++ source/fluentasserts/core/lifecycle.d | 2 + .../core/operations/greaterOrEqualTo.d | 55 +++++++++++++++++++ test/operations/greaterOrEqualTo.d | 55 +++++++++++++++++++ test/test.sh | 25 +++++++++ 5 files changed, 147 insertions(+) create mode 100644 source/fluentasserts/core/operations/greaterOrEqualTo.d create mode 100644 test/operations/greaterOrEqualTo.d create mode 100755 test/test.sh diff --git a/source/fluentasserts/core/expect.d b/source/fluentasserts/core/expect.d index 41c300e..2a2e823 100644 --- a/source/fluentasserts/core/expect.d +++ b/source/fluentasserts/core/expect.d @@ -145,6 +145,11 @@ import std.conv; return opDispatch!"greaterThan"(value); } + /// + auto greaterOrEqualTo(T)(T value) { + return opDispatch!"greaterOrEqualTo"(value); + } + /// auto above(T)(T value) { return opDispatch!"above"(value); @@ -154,6 +159,11 @@ import std.conv; return opDispatch!"lessThan"(value); } + /// + auto lessOrEqualThan(T)(T value) { + return opDispatch!"lessOrEqualThan"(value); + } + /// auto below(T)(T value) { return opDispatch!"below"(value); diff --git a/source/fluentasserts/core/lifecycle.d b/source/fluentasserts/core/lifecycle.d index 5d23b03..f970b52 100644 --- a/source/fluentasserts/core/lifecycle.d +++ b/source/fluentasserts/core/lifecycle.d @@ -10,6 +10,7 @@ import fluentasserts.core.operations.contain; import fluentasserts.core.operations.endWith; import fluentasserts.core.operations.equal; import fluentasserts.core.operations.greaterThan; +import fluentasserts.core.operations.greaterOrEqualTo; import fluentasserts.core.operations.instanceOf; import fluentasserts.core.operations.lessThan; import fluentasserts.core.operations.registry; @@ -47,6 +48,7 @@ static this() { } static foreach(Type; BasicNumericTypes) { + Registry.instance.register(Type.stringof, Type.stringof, "greaterOrEqualTo", &greaterOrEqualTo!Type); Registry.instance.register(Type.stringof, Type.stringof, "greaterThan", &greaterThan!Type); Registry.instance.register(Type.stringof, Type.stringof, "above", &greaterThan!Type); diff --git a/source/fluentasserts/core/operations/greaterOrEqualTo.d b/source/fluentasserts/core/operations/greaterOrEqualTo.d new file mode 100644 index 0000000..5a15c69 --- /dev/null +++ b/source/fluentasserts/core/operations/greaterOrEqualTo.d @@ -0,0 +1,55 @@ +module fluentasserts.core.operations.greaterOrEqualTo; + +import fluentasserts.core.results; +import fluentasserts.core.evaluation; + +import fluentasserts.core.lifecycle; + +import std.conv; + +version(unittest) { + import fluentasserts.core.expect; +} + +/// +IResult[] greaterOrEqualTo(T)(ref Evaluation evaluation) @safe nothrow { + evaluation.message.addText("."); + + T expectedValue; + T currentValue; + + try { + expectedValue = evaluation.expectedValue.strValue.to!T; + currentValue = evaluation.currentValue.strValue.to!T; + } catch(Exception e) { + return [ new MessageResult("Can't convert the values to " ~ T.stringof) ]; + } + + auto result = currentValue >= expectedValue; + + if(evaluation.isNegated) { + result = !result; + } + + if(result) { + return []; + } + + evaluation.message.addText(" "); + evaluation.message.addValue(evaluation.currentValue.strValue); + + IResult[] results = []; + + if(evaluation.isNegated) { + evaluation.message.addText(" is greater or equal than "); + results ~= new ExpectedActualResult("less than " ~ evaluation.expectedValue.strValue, evaluation.currentValue.strValue); + } else { + evaluation.message.addText(" is less than "); + results ~= new ExpectedActualResult("greater or equal than " ~ evaluation.expectedValue.strValue, evaluation.currentValue.strValue); + } + + evaluation.message.addValue(evaluation.expectedValue.strValue); + evaluation.message.addText("."); + + return results; +} diff --git a/test/operations/greaterOrEqualTo.d b/test/operations/greaterOrEqualTo.d new file mode 100644 index 0000000..616a7d8 --- /dev/null +++ b/test/operations/greaterOrEqualTo.d @@ -0,0 +1,55 @@ +module test.operations.greaterOrEqualTo; + +import fluentasserts.core.expect; +import fluent.asserts; + +import trial.discovery.spec; + +import std.string; +import std.conv; +import std.meta; + +alias s = Spec!({ + alias NumericTypes = AliasSeq!(byte, ubyte, short, ushort, int, uint, long, ulong, float, double, real); + + static foreach(Type; NumericTypes) { + describe("using " ~ Type.stringof ~ " values", { + Type smallValue; + Type largeValue; + + before({ + smallValue = cast(Type) 40; + largeValue = cast(Type) 50; + }); + + it("should be able to compare two values", { + expect(largeValue).to.be.greaterOrEqualTo(smallValue); + expect(largeValue).to.be.greaterOrEqualTo(largeValue); + }); + + it("should be able to compare two values using negation", { + expect(smallValue).not.to.be.greaterOrEqualTo(largeValue); + }); + + it("should throw a detailed error when the comparison fails", { + auto msg = ({ + expect(smallValue).to.be.greaterOrEqualTo(largeValue); + }).should.throwException!TestException.msg; + + msg.split("\n")[0].should.equal(smallValue.to!string ~ " should be greater or equal to " ~ largeValue.to!string ~ ". " ~ smallValue.to!string ~ " is less than " ~ largeValue.to!string ~ "."); + msg.split("\n")[2].strip.should.equal("Expected:greater or equal than " ~ largeValue.to!string); + msg.split("\n")[3].strip.should.equal("Actual:" ~ smallValue.to!string); + }); + + it("should throw a detailed error when the negated coparison fails", { + auto msg = ({ + expect(largeValue).not.to.be.greaterOrEqualTo(smallValue); + }).should.throwException!TestException.msg; + + msg.split("\n")[0].should.equal(largeValue.to!string ~ " should not be greater or equal to " ~ smallValue.to!string ~ ". " ~ largeValue.to!string ~ " is greater or equal than " ~ smallValue.to!string ~ "."); + msg.split("\n")[2].strip.should.equal("Expected:less than " ~ smallValue.to!string); + msg.split("\n")[3].strip.should.equal("Actual:" ~ largeValue.to!string); + }); + }); + } +}); diff --git a/test/test.sh b/test/test.sh new file mode 100755 index 0000000..358a1a3 --- /dev/null +++ b/test/test.sh @@ -0,0 +1,25 @@ +/+dub.sdl: +dependency "fluent-asserts" version= "~>0.13.3" ++/ + +import std.stdio; +import fluent.asserts; + +void f2() { + int k = 3; + Assert.equal(k, 4); +} + +void f1() { + int j = 2; + f2(); +} + +void f0() { + int i = 1; + f1(); +} + +void main() { + f0(); +} \ No newline at end of file