public void Assert <T>(AssertionState <T> assertionState)
{
var tType = typeof(T);
Type nullableType = Nullable.GetUnderlyingType(tType);
if (nullableType != null)
{
if (AreEqual(assertionState, x => x == null ? (object)null : (object)_valueTypeDefaults[nullableType]))
{
throw new Exception();
}
return;
}
if (tType == typeof(String))
{
if (AreEqual(assertionState, x => String.IsNullOrWhiteSpace(x as String), true))
{
throw new Exception();
}
return;
}
if (AreEqual(assertionState, default(T)))
{
throw new Exception();
}
}
public void IEnumerable()
{
var testStatePass = new AssertionState <IEnumerable <int> >(() => Enumerable.Repeat(5, 5))
{
IsNegated = true
};
var testStateFail = new AssertionState <IEnumerable <int> >(() => Enumerable.Repeat(5, 0))
{
IsNegated = true
};
var testStatePass2 = new AssertionState <IQueryable <double> >(() => new double[] { 35.2165, 1522.5, 15 }.AsQueryable())
{
IsNegated = true
};
var testStateFail2 = new AssertionState <IQueryable <double> >(() => new double[] {}.AsQueryable())
{
IsNegated = true
};
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
var exPass2 = Record.Exception(() => _subject.Assert(testStatePass2));
var exFail2 = Record.Exception(() => _subject.Assert(testStateFail2));
Assert.Null(exPass);
Assert.NotNull(exFail);
Assert.Null(exPass2);
Assert.NotNull(exFail2);
}
public void List()
{
var testStatePass = new AssertionState <List <int> >(() => new List <int> {
35, 152, 15
})
{
IsNegated = true
};
var testStateFail = new AssertionState <List <int> >(() => new List <int> {
})
{
IsNegated = true
};
var testStatePass2 = new AssertionState <double[]>(() => new double[] { 35.2165, 1522.5, 15 })
{
IsNegated = true
};
var testStateFail2 = new AssertionState <double[]>(() => new double[] {})
{
IsNegated = true
};
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
var exPass2 = Record.Exception(() => _subject.Assert(testStatePass2));
var exFail2 = Record.Exception(() => _subject.Assert(testStateFail2));
Assert.Null(exPass);
Assert.NotNull(exFail);
Assert.Null(exPass2);
Assert.NotNull(exFail2);
}
public void Assert <T>(AssertionState <T> assertionState)
{
if (!AreEqual(assertionState, true))
{
throw new Exception();
}
}
protected bool AreEqual <T>(AssertionState <T> assertionState, Func <T, object> toEqualTransformer)
{
var testValue = assertionState.TestExpression();
var toEqual = toEqualTransformer(testValue);
return(AreEqual(testValue, toEqual, assertionState.IsNegated));
}
public void String()
{
var testStatePass = new AssertionState <string>(() => "Not Empty")
{
IsNegated = true
};
var testStatePass2 = new AssertionState <string>(() => " ")
{
IsNegated = true
};
var testStateFail = new AssertionState <string>(() => "")
{
IsNegated = true
};
var testStateFail2 = new AssertionState <string>(() => System.String.Empty)
{
IsNegated = true
};
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exPass2 = Record.Exception(() => _subject.Assert(testStatePass2));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
var exFail2 = Record.Exception(() => _subject.Assert(testStateFail2));
Assert.Null(exPass);
Assert.Null(exPass2);
Assert.NotNull(exFail);
Assert.NotNull(exFail2);
}
public void Assert <T>(AssertionState <T> assertionState, Type assertedType)
{
if (!AreEqual(assertionState, x => x == null ? typeof(T) : x.GetType(), assertedType))
{
throw new Exception();
}
}
public void ReferenceTypes()
{
var testState = new AssertionState <StubClass>(() => new StubClass());
var exFail = Record.Exception(() => _subject.Assert(testState));
Assert.NotNull(exFail);
}
public void ReferenceTypes()
{
var testState = new AssertionState<StubClass>(() => new StubClass()) { IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testState));
Assert.Null(exPass);
}
public void ValueTypes()
{
var testState = new AssertionState <int>(() => 1);
var exFail = Record.Exception(() => _subject.Assert(testState));
Assert.NotNull(exFail);
}
public void ValueTypes()
{
var testState = new AssertionState<int>(() => 1) { IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testState));
Assert.Null(exPass);
}
public void Null()
{
var testState = new AssertionState <StubClass>(() => null);
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(StubClass)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(NotStubClass)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Null()
{
var testState = new AssertionState<StubClass>(() => null){ IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(NotStubClass)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(StubClass)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void ValueTypes()
{
var testState = new AssertionState <int>(() => 1)
{
IsNegated = true
};
var exPass = Record.Exception(() => _subject.Assert(testState));
Assert.Null(exPass);
}
public void WithoutLength()
{
var testStateFail = new AssertionState <bool>(() => true);
var testStateFail2 = new AssertionState <StubClass>(() => new StubClass());
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
var exFail2 = Record.Exception(() => _subject.Assert(testStateFail2));
Assert.NotNull(exFail);
Assert.NotNull(exFail2);
}
public void ReferenceTypes()
{
var testState = new AssertionState <StubClass>(() => new StubClass())
{
IsNegated = true
};
var exPass = Record.Exception(() => _subject.Assert(testState));
Assert.Null(exPass);
}
public void Int32()
{
var testStatePass = new AssertionState <int>(() => 1);
var testStateFail = new AssertionState <int>(() => 0);
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void PolymorphedClasses()
{
var testValue = new StubClassContainer();
var testState = new AssertionState<StubClass>(() => testValue.StubClass){ IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(StubClass)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(StubSubClass)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void ReferenceTypes()
{
var testValue = new StubClass();
var testState = new AssertionState<StubClass>(() => testValue){ IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(NotStubClass)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(StubClass)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Boolean()
{
var testStatePass = new AssertionState <bool>(() => true);
var testStateFail = new AssertionState <bool>(() => false);
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Nullables()
{
var testStatePass = new AssertionState <bool?>(() => (bool?)null);
var testStateFail = new AssertionState <bool?>(() => true);
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void PolymorphedClasses()
{
var testValue = new StubClassContainer();
var testState = new AssertionState <StubClass>(() => testValue.StubClass);
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(StubSubClass)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(StubClass)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Int32()
{
var testStateFail = new AssertionState<int>(() => 1) { IsNegated = true };
var testStatePass = new AssertionState<int>(() => 0) { IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void ReferenceTypes()
{
var testValue = new StubClass();
var testState = new AssertionState <StubClass>(() => testValue);
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(StubClass)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(NotStubClass)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Boolean()
{
var testStatePass = new AssertionState<bool>(() => false) { IsNegated = true };
var testStateFail = new AssertionState<bool>(() => true) { IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void ValueTypes()
{
var testValue = 1;
var testState = new AssertionState <int>(() => testValue);
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(int)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(bool)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void String()
{
var testValue = @"I'm a string!";
var otherValue = @"I'm another string!";
var testState = new AssertionState <string>(() => testValue);
var exPass = Record.Exception(() => _subject.Assert(testState, testValue));
var exFail = Record.Exception(() => _subject.Assert(testState, otherValue));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Mutates_AssertionState()
{
var assertionState = new AssertionState <int>(() => 1)
{
IsNegated = false
};
var subject = new Subject(assertionState, null);
var notSubject = subject.Not;
Assert.True(assertionState.IsNegated);
}
public void Object()
{
var testValue = new StubClass();
var otherValue = new NotStubClass();
var testState = new AssertionState <object>(() => testValue);
var exPass = Record.Exception(() => _subject.Assert(testState, testValue));
var exFail = Record.Exception(() => _subject.Assert(testState, otherValue));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Mutates_AssertionState()
{
var assertionState = new AssertionState<int>(() => 1)
{
IsNegated = false
};
var subject = new Subject(assertionState, null);
var notSubject = subject.Not;
Assert.True(assertionState.IsNegated);
}
public void Int32()
{
var testValue = 156132156;
var otherValue = 5651156;
var testState = new AssertionState <Int32>(() => testValue);
var exPass = Record.Exception(() => _subject.Assert(testState, testValue));
var exFail = Record.Exception(() => _subject.Assert(testState, otherValue));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Passes_state_to_registered_asserter()
{
var assertionState = new AssertionState<int>(() => 1);
var asserterFactory = A.Fake<IAsserterFactory>();
var asserter = A.Fake<IEqualAsserter>();
A.CallTo(() => asserterFactory.Get<IEqualAsserter>()).Returns(asserter);
var subject = new Subject(assertionState, asserterFactory);
subject.Equal(1);
A.CallTo(() => asserter.Assert(assertionState, 1)).MustHaveHappened();
}
public void Subclasses()
{
var testValue = new StubSubClass();
var testState = new AssertionState <StubClass>(() => testValue)
{
IsNegated = true
};
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(StubClass)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(StubSubClass)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Int32()
{
var testValue = 1;
var testState = new AssertionState <Int32>(() => testValue)
{
IsNegated = true
};
var exPass = Record.Exception(() => _subject.Assert(testState, 2));
var exFail = Record.Exception(() => _subject.Assert(testState, testValue));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void String()
{
var testValue = @"I'm a string!";
var testState = new AssertionState <string>(() => testValue)
{
IsNegated = true
};
var exPass = Record.Exception(() => _subject.Assert(testState, @"I'm a different string!"));
var exFail = Record.Exception(() => _subject.Assert(testState, testValue));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Object()
{
var testValue = new { I = "Have ", AtLeast = 3, Properties = true };
var testState = new AssertionState <object>(() => testValue)
{
IsNegated = true
};
var exPass = Record.Exception(() => _subject.Assert(testState, new {}));
var exFail = Record.Exception(() => _subject.Assert(testState, testValue));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void Nullable()
{
var testStatePass = new AssertionState<bool?>(() => (bool?)true) { IsNegated = true };
var testStateFail = new AssertionState<bool?>(() => (bool?)false) { IsNegated = true };
var testStateFail2 = new AssertionState<bool?>(() => (bool?)null) { IsNegated = true };
var exFail = Record.Exception(() => _subject.Assert(testStatePass));
var exPass = Record.Exception(() => _subject.Assert(testStateFail));
var exPass2 = Record.Exception(() => _subject.Assert(testStateFail2));
Assert.NotNull(exFail);
Assert.Null(exPass);
Assert.Null(exPass2);
}
public void Passes_state_to_registered_asserter()
{
var assertionState = new AssertionState <int>(() => 1);
var asserterFactory = A.Fake <IAsserterFactory>();
var asserter = A.Fake <IEqualAsserter>();
A.CallTo(() => asserterFactory.Get <IEqualAsserter>()).Returns(asserter);
var subject = new Subject(assertionState, asserterFactory);
subject.Equal(1);
A.CallTo(() => asserter.Assert(assertionState, 1)).MustHaveHappened();
}
public void Passes_state_to_registered_asserter()
{
var assertionState = new AssertionState <int>(() => 1);
var asserterFactory = A.Fake <IAsserterFactory>();
var asserter = A.Fake <ITypeAsserter>();
A.CallTo(() => asserterFactory.Get <ITypeAsserter>()).Returns(asserter);
var subject = new Subject(assertionState, asserterFactory);
subject.A <int>();
subject.An <int>();
A.CallTo(() => asserter.Assert(assertionState, typeof(int))).MustHaveHappened(Exactly.Twice);
}
public void Assert <T>(AssertionState <T> assertionState)
{
if (typeof(T) == typeof(String))
{
if (!AreEqual(assertionState, x => (x as String).Length, 0))
{
throw new Exception();
}
return;
}
if (typeof(IEnumerable).IsAssignableFrom(typeof(T)))
{
if (!AreEqual(assertionState, x =>
{
if (x as ICollection != null)
{
return(((ICollection)x).Count);
}
var count = 0;
var enumerator = ((IEnumerable)x).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
count++;
}
}
finally
{
if (enumerator as IDisposable != null)
{
((IDisposable)enumerator).Dispose();
}
}
return(count);
}, 0))
{
throw new Exception();
}
return;
}
throw new Exception();
}
public void String()
{
var testStatePass = new AssertionState<string>(() => "Not Empty") { IsNegated = true };
var testStatePass2 = new AssertionState<string>(() => " ") { IsNegated = true };
var testStateFail = new AssertionState<string>(() => "") { IsNegated = true };
var testStateFail2 = new AssertionState<string>(() => System.String.Empty) { IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exPass2 = Record.Exception(() => _subject.Assert(testStatePass2));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
var exFail2 = Record.Exception(() => _subject.Assert(testStateFail2));
Assert.Null(exPass);
Assert.Null(exPass2);
Assert.NotNull(exFail);
Assert.NotNull(exFail2);
}
public void List()
{
var testStatePass = new AssertionState<List<int>>(() => new List<int> { 35, 152, 15}) { IsNegated = true };
var testStateFail = new AssertionState<List<int>>(() => new List<int> {}) { IsNegated = true };
var testStatePass2 = new AssertionState<double[]>(() => new double[] { 35.2165, 1522.5, 15}) { IsNegated = true };
var testStateFail2 = new AssertionState<double[]>(() => new double[] {}) { IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
var exPass2 = Record.Exception(() => _subject.Assert(testStatePass2));
var exFail2 = Record.Exception(() => _subject.Assert(testStateFail2));
Assert.Null(exPass);
Assert.NotNull(exFail);
Assert.Null(exPass2);
Assert.NotNull(exFail2);
}
public void IEnumerable()
{
var testStatePass = new AssertionState<IEnumerable<int>>(() => Enumerable.Repeat(5,5)) { IsNegated = true };
var testStateFail = new AssertionState<IEnumerable<int>>(() => Enumerable.Repeat(5,0)) { IsNegated = true};
var testStatePass2 = new AssertionState<IQueryable<double>>(() => new double[] { 35.2165, 1522.5, 15}.AsQueryable()) { IsNegated = true };
var testStateFail2 = new AssertionState<IQueryable<double>>(() => new double[] {}.AsQueryable()) { IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
var exPass2 = Record.Exception(() => _subject.Assert(testStatePass2));
var exFail2 = Record.Exception(() => _subject.Assert(testStateFail2));
Assert.Null(exPass);
Assert.NotNull(exFail);
Assert.Null(exPass2);
Assert.NotNull(exFail2);
}
public void String()
{
var testStatePass = new AssertionState<string>(() => "A truthy string!");
var testStateFail = new AssertionState<string>(() => null);
var testStateFail2 = new AssertionState<string>(() => System.String.Empty);
var testStateFail3 = new AssertionState<string>(() => "");
var testStateFail4 = new AssertionState<string>(() => " ");
var exPass = Record.Exception(() => _subject.Assert(testStatePass));
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
var exFail2 = Record.Exception(() => _subject.Assert(testStateFail2));
var exFail3 = Record.Exception(() => _subject.Assert(testStateFail3));
var exFail4 = Record.Exception(() => _subject.Assert(testStateFail4));
Assert.Null(exPass);
Assert.NotNull(exFail);
Assert.NotNull(exFail2);
Assert.NotNull(exFail3);
Assert.NotNull(exFail4);
}
public void ReferenceTypes()
{
var testState = new AssertionState<StubClass>(() => new StubClass());
var exFail = Record.Exception(() => _subject.Assert(testState));
Assert.NotNull(exFail);
}
public void ValueTypes()
{
var testState = new AssertionState<int>(() => 1);
var exFail = Record.Exception(() => _subject.Assert(testState));
Assert.NotNull(exFail);
}
public void Passes_state_to_registered_asserter()
{
var assertionState = new AssertionState<int>(() => 1);
var asserterFactory = A.Fake<IAsserterFactory>();
var asserter = A.Fake<ITypeAsserter>();
A.CallTo(() => asserterFactory.Get<ITypeAsserter>()).Returns(asserter);
var subject = new Subject(assertionState, asserterFactory);
subject.A<int>();
subject.An<int>();
A.CallTo(() => asserter.Assert(assertionState, typeof(int))).MustHaveHappened(Exactly.Twice);
}
public void Subclasses()
{
var testValue = new StubSubClass();
var testState = new AssertionState<StubClass>(() => testValue);
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(StubSubClass)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(StubClass)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void ValueTypes()
{
var testValue = 1;
var testState = new AssertionState<int>(() => testValue){ IsNegated = true };
var exPass = Record.Exception(() => _subject.Assert(testState, typeof(bool)));
var exFail = Record.Exception(() => _subject.Assert(testState, typeof(int)));
Assert.Null(exPass);
Assert.NotNull(exFail);
}
public void WithoutLength()
{
var testStateFail = new AssertionState<bool>(() => true) { IsNegated = true };
var testStateFail2 = new AssertionState<StubClass>(() => new StubClass()) { IsNegated = true };
var exFail = Record.Exception(() => _subject.Assert(testStateFail));
var exFail2 = Record.Exception(() => _subject.Assert(testStateFail2));
Assert.NotNull(exFail);
Assert.NotNull(exFail2);
}
