public void ReachAllInnerClasses() { // # Arrange. var pr = new PseudoRandom(nameof(ReachAllInnerClasses)); var obj = new MyPublicClass(); dynamic sut = new ReachIn(obj); int res; int val; // # Act and Assert. val = pr.Int(); // We don't support finding privates in inherited classes // so here we look for a field overloaded in the child class // just as a sanity check. sut._myInnerPrivateClass._myPrivateField = val; res = sut._myInnerPrivateClass._myPrivateField; res.Should().Be(val); // Keep looking for a visible (e.g. internal) field that comes // from the base class. sut._myInnerPrivateClass._myInternalField = val; res = sut._myInnerPrivateClass._myInternalField; res.Should().Be(val); sut._myInnerInternalClass._myInternalField = val; res = sut._myInnerInternalClass._myInternalField; res.Should().Be(val); sut._myInnerProtectedClass._myInternalField = val; res = sut._myInnerProtectedClass._myInternalField; res.Should().Be(val); sut._myInnerPublicClass._myInternalField = val; res = sut._myInnerPublicClass._myInternalField; res.Should().Be(val); }
public void ThrowExceptionOverloadedMember() { // # Arrange. dynamic sut = new ReachIn(new MyOverloadedMethodClass()); // # Act and Assert. Assert.Throws <Exception>( () => sut.MyMethod); }
public void ThrowExceptionIfStaticFieldOrPropetyNotFound() { // # Arrange. var pr = new PseudoRandom(nameof(ThrowExceptionIfStaticFieldOrPropetyNotFound)); dynamic sut = new ReachIn(typeof(MyBaseClass)); // # Act and Assert. // A setter does not exist. Assert.Throws <Exception>( () => { sut.ThisPropertyOrFieldIsNotFound = pr.Int(); }); // A getter does not exist. Assert.Throws <Exception>( () => { var res = sut.ThisPropertyOrFieldIsNotFound; }); }
public void ThrowExceptionIfMethodNotFound() { // # Arrange. var pr = new PseudoRandom(nameof(ThrowExceptionIfMethodNotFound)); var obj = new MyBaseClass(); dynamic sut = new ReachIn(obj); // # Act and Assert. // The method does not exist. Assert.Throws <Exception>( () => { sut.ThisMethodIsNotFound(pr.Int()); }); // There is a property by the same name. Assert.Throws <RuntimeBinderException>( () => { sut.MyPrivateProperty(pr.Int()); }); }
public void ThrowExceptionIfStaticMethodNotFound() { // # Arrange. var pr = new PseudoRandom(nameof(ThrowExceptionIfStaticMethodNotFound)); dynamic sut = new ReachIn(typeof(MyBaseClass)); // # Act and Assert. // The method does not exist. Assert.Throws <Exception>( () => { sut.ThisMethodIsNotFound(pr.Int()); }); // There is a property by the same name. // Trying to call it fails. Assert.Throws <RuntimeBinderException>( () => { sut.MyStaticPrivateProperty(pr.Int()); }); }
public void ReachAllStaticFieldsAndProperties() { // # Arrange. var pr = new PseudoRandom(nameof(ReachAllStaticFieldsAndProperties)); dynamic sut = new ReachIn(typeof(MyBaseClass)); int value, res; // # Act and Assert. // ## Fields. value = pr.Int(); sut._myStaticPrivateField = value; res = sut._myStaticPrivateField; res.Should().Be(value); value = pr.Int(); sut._myStaticInternalField = value; res = sut._myStaticInternalField; res.Should().Be(value); value = pr.Int(); sut._myStaticProtectedField = value; res = sut._myStaticProtectedField; res.Should().Be(value); value = pr.Int(); sut._myStaticPublicField = value; res = sut._myStaticPublicField; res.Should().Be(value); // ## Properties. value = pr.Int(); sut.MyStaticPrivateProperty = value; res = sut.MyStaticPrivateProperty; res.Should().Be(value); value = pr.Int(); sut.MyStaticInternalProperty = value; res = sut.MyStaticInternalProperty; res.Should().Be(value); value = pr.Int(); sut.MyStaticProtectedProperty = value; res = sut.MyStaticProtectedProperty; res.Should().Be(value); value = pr.Int(); sut.MyStaticPublicProperty = value; res = sut.MyStaticPublicProperty; res.Should().Be(value); }
public void ReachAllStaticMethods() { // # Arrange. var pr = new PseudoRandom(nameof(ReachAllStaticMethods)); dynamic sut = new ReachIn(typeof(MyBaseClass)); var val = pr.Int(); // # Act and Assert. // We have a problem here with FluentAssertions where it, runtime, throws an exception even though the parameters are equal. //sut.MyStaticPrivateMethod(val).Should().Be(val + 1); //sut.MyStaticInternalMethod(val).Should().Be(val+1); //sut.MyStaticProtectedMethod(val).Should().Be(val+1); //sut.MyStaticPublicMethod(val).Should().Be(val+1); Assert.Equal(val + 1, sut.MyStaticPrivateMethod(val)); Assert.Equal(val + 1, sut.MyStaticInternalMethod(val)); Assert.Equal(val + 1, sut.MyStaticProtectedMethod(val)); Assert.Equal(val + 1, sut.MyStaticPublicMethod(val)); }
public override bool TryGetMember(GetMemberBinder binder, out object result) { if (type == null) { result = new ReachIn(Type.GetType($"{@namespace}.{binder.Name}".Trim('.'))); return(true); } var member = type.GetMember(binder.Name).Single(); if (member.MemberType == MemberTypes.NestedType) { result = new ReachIn((Type)member); } else { result = null; return(false); } return(true); }
public void ReachAllFieldsOfAllTypes() { // # Arrange. var pr = new PseudoRandom(nameof(ReachAllFieldsOfAllTypes)); dynamic sut = new ReachIn(typeof(MyStaticBaseClassWithTypes)); // # Act and Assert. var anyIntValue = pr.Int(); sut._myPrivateStaticIntField = anyIntValue; // We have a problem here with FluentAssertions where it, runtime, throws an exception even though the parameters are equal. //sut._myPrivateStaticIntField.Should().be(anyIntValue); Assert.Equal(anyIntValue, sut._myPrivateStaticIntField); var anyStringValue = pr.String(); sut._myPrivateStaticStringField = anyStringValue; // We have a problem here with FluentAssertions where it, runtime, throws an exception even though the parameters are equal. //sut._myPrivateStaticStringField.Should().Be(anyStringValue); Assert.Equal(anyStringValue, sut._myPrivateStaticStringField); var anyLongValue = pr.PositiveLong(); sut._myPrivateStaticLongField = anyLongValue; // We have a problem here with FluentAssertions where it, runtime, throws an exception even though the parameters are equal. //sut._myPrivateStaticLongField.Should().be(anyLongValue); Assert.Equal(anyLongValue, sut._myPrivateStaticLongField); var anyObject = new { FieldOne = pr.Int(), }; sut._myPrivateStaticObjectField = anyObject; // We have a problem here with FluentAssertions where it, runtime, throws an exception even though the parameters are equal. //sut._myPrivateStaticObjectField.FieldOne.Should().Be(anyObject.FieldOne); Assert.Equal(anyObject.FieldOne, sut._myPrivateStaticObjectField.FieldOne); // If there is any other type to test, this is the place to add. }
public void ObjAndSutUseTheSameInstance() { // # Arrange. var pr = new PseudoRandom(nameof(ObjAndSutUseTheSameInstance)); var obj = new MyBaseClass(); dynamic sut = new ReachIn(obj); dynamic sut2 = new ReachIn(obj); var value = pr.Int(); value.Should().NotBe(default(int), "Sanity check we haven't randomised the default 0 value since all tests then would be moot."); // # Act. sut.MyPublicProperty = value; sut2.MyPublicProperty = value; // # Assert. value.Should().Be(obj.MyPublicProperty); // We have a problem here with FluentAssertions where it, runtime, throws an exception even though the parameters are equal. //sut2.MyPublicProperty.Should().Be(sut.MyPublicProperty); Assert.Equal(sut.MyPublicProperty, sut2.MyPublicProperty); }
// Static methods. //[InlineData("MyStaticPrivateMethod")] //[InlineData("MyStaticInternalMethod")] //[InlineData("MyStaticProtectedMethod")] //[InlineData("MyStaticPublicMethod")] public void GetMemberOrThrow_ValidNameInParent_ReturnMember(string memberName) { var sut = new ReachIn(typeof(ReachIn)); Assert_CanFind(sut, typeof(MyChildClass), memberName); }
public void GetMemberOrThrow_ValidName_ReturnMember(string memberName) { dynamic sut = new ReachIn(typeof(ReachIn)); Assert_CanFind(sut, typeof(MyBaseClass), memberName); }