TestEqualsClass

Undocumented in source.

version(unittest)

@trusted @safe

class TestEqualsClass {

int value;

this(int value);

void f();

}

Constructors

this this(int value): Undocumented in source.

Members

Functions

f void f(): Undocumented in source. Be warned that the author may not have intended to support it.

Variables

value int value;: Undocumented in source.

Examples

array equals with classes

({
  auto instance = new TestEqualsClass(1);
  [instance].should.equal([instance]);
}).should.not.throwAnyException;

({
  [new TestEqualsClass(2)].should.equal([new TestEqualsClass(1)]);
}).should.throwException!TestException;

range equals

({
  [1, 2, 3].map!"a".should.equal([1, 2, 3]);
}).should.not.throwAnyException;

({
  [1, 2, 3].map!"a".should.not.equal([2, 1, 3]);
  [1, 2, 3].map!"a".should.not.equal([2, 3]);
  [2, 3].map!"a".should.not.equal([1, 2, 3]);
}).should.not.throwAnyException;

auto msg = ({
  [1, 2, 3].map!"a".should.equal([4, 5]);
}).should.throwException!TestException.msg;

msg.split("\n")[0].strip.should.equal(`[1, 2, 3].map!"a" should equal [4, 5].`);

msg = ({
  [1, 2].map!"a".should.equal([4, 5]);
}).should.throwException!TestException.msg;

msg.split("\n")[0].strip.should.equal(`[1, 2].map!"a" should equal [4, 5].`);

msg = ({
  [1, 2, 3].map!"a".should.equal([2, 3, 1]);
}).should.throwException!TestException.msg;

msg.split("\n")[0].strip.should.equal(`[1, 2, 3].map!"a" should equal [2, 3, 1].`);

msg = ({
  [1, 2, 3].map!"a".should.not.equal([1, 2, 3]);
}).should.throwException!TestException.msg;

msg.split("\n")[0].strip.should.startWith(`[1, 2, 3].map!"a" should not equal [1, 2, 3]`);

custom range asserts

struct Range {
  int n;
  int front() {
    return n;
  }
  void popFront() {
    ++n;
  }
  bool empty() {
    return n == 3;
  }
}

Range().should.equal([0,1,2]);
Range().should.contain([0,1]);
Range().should.contain(0);

auto msg = ({
  Range().should.equal([0,1]);
}).should.throwException!TestException.msg;

msg.split("\n")[0].strip.should.startWith("Range() should equal [0, 1]");

msg = ({
  Range().should.contain([2, 3]);
}).should.throwException!TestException.msg;

msg.split("\n")[0].strip.should.startWith("Range() should contain [2, 3]. 3 is missing from [0, 1, 2].");

msg = ({
  Range().should.contain(3);
}).should.throwException!TestException.msg;

msg.split("\n")[0].strip.should.startWith("Range() should contain 3. 3 is missing from [0, 1, 2].");

custom const range equals

struct ConstRange {
  int n;
  const(int) front() {
    return n;
  }

  void popFront() {
    ++n;
  }

  bool empty() {
    return n == 3;
  }
}

[0,1,2].should.equal(ConstRange());
ConstRange().should.equal([0,1,2]);

custom immutable range equals

struct ImmutableRange {
  int n;
  immutable(int) front() {
    return n;
  }

  void popFront() {
    ++n;
  }

  bool empty() {
    return n == 3;
  }
}

[0,1,2].should.equal(ImmutableRange());
ImmutableRange().should.equal([0,1,2]);

approximately equals

[0.350, 0.501, 0.341].should.be.approximately([0.35, 0.50, 0.34], 0.01);

[0.350, 0.501, 0.341].should.not.be.approximately([0.35, 0.50, 0.34], 0.00001);
[0.350, 0.501, 0.341].should.not.be.approximately([0.501, 0.350, 0.341], 0.001);
[0.350, 0.501, 0.341].should.not.be.approximately([0.350, 0.501], 0.001);
[0.350, 0.501].should.not.be.approximately([0.350, 0.501, 0.341], 0.001);

auto msg = ({
  [0.350, 0.501, 0.341].should.be.approximately([0.35, 0.50, 0.34], 0.0001);
}).should.throwException!TestException.msg;

msg.should.contain("Expected:[0.35±0.0001, 0.5±0.0001, 0.34±0.0001]");
msg.should.contain("Missing:[0.501±0.0001, 0.341±0.0001]");

approximately equals with Assert

Assert.approximately([0.350, 0.501, 0.341], [0.35, 0.50, 0.34], 0.01);
Assert.notApproximately([0.350, 0.501, 0.341], [0.350, 0.501], 0.0001);

immutable string

immutable string[] someList;

someList.should.equal([]);

Compare const objects

class A {}
A a = new A();
const(A)[] arr = [a];
arr.should.equal([a]);