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); }