public void ShouldSetPrototypeProperty()
        {
            // Given
            string  expected = Guid.NewGuid().ToString();
            dynamic element  = new SomePrototype();

            // When
            element.PrototypeProperty = expected;
            dynamic actual = element.PrototypeProperty;

            // Then
            Assert.AreEqual(expected, actual);
        }
        public void ShouldReplacePrototypeProperties()
        {
            // Given
            DateTime wrongTypeValue = DateTime.Now;
            dynamic  element        = new SomePrototype();

            // When
            element.PrototypeProperty = wrongTypeValue;
            dynamic actual = element.PrototypeProperty;

            // Then
            Assert.AreEqual(wrongTypeValue, actual);
        }
        public void ShouldSetPrototypeMethod()
        {
            // Given
            var element = new SomePrototype();

            // When
            ((dynamic)element).PrototypeMethod = new Func <string, string>(a => "NewMethod");
            Func <string, string> actual = ((dynamic)element).PrototypeMethod;

            // Then
            Assert.IsNotNull(actual);
            Assert.AreEqual("NewMethod", actual("Arg1"));
        }
        public void ShouldGetAndSetDynamicProperty()
        {
            // Given
            var     expected = new object();
            dynamic element  = new SomePrototype();

            // When
            element.DynamicProperty = expected;
            dynamic actual = element.DynamicProperty;

            // Then
            Assert.AreEqual(expected, actual);
        }
        public void ShouldReplacePrototypeMethods()
        {
            // Given
            Func <int> delegateWithWrongSignature = () => 12345;
            dynamic    element = new SomePrototype();

            // When
            element.PrototypeMethod = delegateWithWrongSignature;
            Func <int> actual = element.PrototypeMethod;

            // Then
            Assert.IsNotNull(actual);
            Assert.AreEqual(12345, actual());
        }
        public void ShouldInvokeDynamicMethod()
        {
            // Given
            Guid    expected = Guid.NewGuid();
            dynamic element  = new SomePrototype();

            element.DynamicMethod = new Func <object>(() => expected);

            // When
            dynamic actual = element.DynamicMethod();

            // Then
            Assert.AreEqual(expected, actual);
        }
        public void ShouldGetPrototypeMethod()
        {
            // Given
            var element = new SomePrototype();
            Func <string, string> expected = element.PrototypeMethod;

            // When
            Func <string, string> actual = ((dynamic)element).PrototypeMethod;

            // Then
            Assert.IsNotNull(actual);
            Assert.AreEqual(expected, actual);
            Assert.AreEqual(expected("Arg1"), actual("Arg1"));
        }
        public void ShouldGetPrototypeField()
        {
            // Given
            string  expected = Guid.NewGuid().ToString();
            dynamic element  = new SomePrototype {
                PrototypeField = expected
            };

            // When
            dynamic actual = element.PrototypeField;

            // Then
            Assert.AreEqual(expected, actual);
        }
        public void ShouldAddDynamicMethodWhenSubscribe()
        {
            // Given
            Guid          expected     = Guid.NewGuid();
            dynamic       element      = new SomePrototype();
            Func <object> subscription = () => expected;

            // When
            element.DynamicMethod += subscription;
            dynamic actual = element.DynamicMethod();

            // Then
            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 10
0
        public void ShouldRemoveDynamicMethodWhenUnsubscribe()
        {
            // Given
            Guid          expected     = Guid.NewGuid();
            dynamic       element      = new SomePrototype();
            Func <object> subscription = () => expected;

            element.DynamicMethod = subscription;

            // When
            element.DynamicMethod -= subscription;
            dynamic actual = element.DynamicMethod;

            // Then
            Assert.IsNull(actual);
        }
Exemplo n.º 11
0
        public void ShouldReplacePrototypeEvents()
        {
            // Given
            string result  = string.Empty;
            var    element = new SomePrototype();

            element.PrototypeEvent += () => result += "Handler1";
            element.PrototypeEvent += () => result += "Handler2";
            Func <int> delegateWithWrongSignature = () => 12345;

            // When
            ((dynamic)element).PrototypeEvent = delegateWithWrongSignature;
            Func <int> actual = ((dynamic)element).PrototypeEvent;

            // Then
            Assert.IsNotNull(actual);
            Assert.AreEqual(12345, actual());
        }
Exemplo n.º 12
0
        public void ShouldGetPrototypeEvent()
        {
            // Given
            string result  = string.Empty;
            var    element = new SomePrototype();

            element.PrototypeEvent += () => result += "Handler1";
            element.PrototypeEvent += () => result += "Handler2";

            // When
            Action actual = ((dynamic)element).PrototypeEvent;

            // Then

            Assert.IsNotNull(actual);

            actual();
            Assert.AreEqual("Handler1Handler2", result);
        }