How to use MePrivate method of JustMock.NonElevatedExamples.AdvancedUsage.PrivateAccessorNamespace.ClassWithNonPublicMembers class

1/*
2 JustMock Lite
3 Copyright © 2010-2014 Telerik EAD
4
5   Licensed under the Apache License, Version 2.0 (the "License");
6   you may not use this file except in compliance with the License.
7   You may obtain a copy of the License at
8
9     http://www.apache.org/licenses/LICENSE-2.0
10
11   Unless required by applicable law or agreed to in writing, software
12   distributed under the License is distributed on an "AS IS" BASIS,
13   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   See the License for the specific language governing permissions and
15   limitations under the License.
16*/
17
18using System;
19using Microsoft.VisualStudio.TestTools.UnitTesting;
20using Telerik.JustMock;
21
22namespace JustMock.NonElevatedExamples.AdvancedUsage.PrivateAccessorNamespace
23{
24    /// <summary>
25    /// The Telerik JustMock PrivateAccessor allows you to call non-public members of the tested code right in your unit tests. 
26    /// See http://www.telerik.com/help/justmock/advanced-usage-private-accessor.html for full documentation of the feature.
27    /// </summary>
28    [TestClass]
29    public class PrivateAccessor_Tests
30    {
31        [TestMethod]
32        public void PrivateAccessor_ShouldCallPrivateMethod()
33        {
34            // ACT
35            // Wrapping the instance holding the private method.
36            var inst = new PrivateAccessor(new ClassWithNonPublicMembers());
37            // Calling the non-public method by giving its exact name.
38            var actual = inst.CallMethod("MePrivate");
39
40            // ASSERT
41            Assert.AreEqual(1000, actual);
42        }
43
44        [TestMethod]
45        public void PrivateAccessor_ShouldCallPrivateStaticMethod()
46        {
47            // ACT
48            // Wrapping the instance holding the private method by type.
49            var inst = PrivateAccessor.ForType(typeof(ClassWithNonPublicMembers));
50            // Calling the non-public static method by giving its exact name.
51            var actual = inst.CallMethod("MeStaticPrivate");
52
53            // ASSERT
54            Assert.AreEqual(2000, actual);
55        }
56
57        [TestMethod]
58        public void PrivateAccessor_ShouldGetSetProperty()
59        {
60            // ACT
61            // Wrapping the instance holding the private property.
62            var inst = new PrivateAccessor(new ClassWithNonPublicMembers());
63            // Setting the value of the private property.
64            inst.SetProperty("Prop", 555);
65
66            // ASSERT - Asserting with getting the value of the private property.
67            Assert.AreEqual(555, inst.GetProperty("Prop"));
68        } 
69    }
70
71    #region SUT
72    public class ClassWithNonPublicMembers
73    {
74        private int Prop { get; set; }
75
76        private int MePrivate()
77        {
78            return 1000;
79        }
80
81        private static int MeStaticPrivate()
82        {
83            return 2000;
84        }
85    } 
86    #endregion
87}
88

Source: PrivateAccessor.cs

/*
 JustMock Lite
 Copyright © 2010-2014 Telerik EAD

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Telerik.JustMock;

namespace JustMock.NonElevatedExamples.AdvancedUsage.PrivateAccessorNamespace
{
    /// <summary>
    /// The Telerik JustMock PrivateAccessor allows you to call non-public members of the tested code right in your unit tests. 
    /// See http://www.telerik.com/help/justmock/advanced-usage-private-accessor.html for full documentation of the feature.
    /// </summary>
    [TestClass]
    public class PrivateAccessor_Tests
    {
        [TestMethod]
        public void PrivateAccessor_ShouldCallPrivateMethod()
        {
            // ACT
            // Wrapping the instance holding the private method.
            var inst = new PrivateAccessor(new ClassWithNonPublicMembers());
            // Calling the non-public method by giving its exact name.
            var actual = inst.CallMethod("MePrivate");

            // ASSERT
            Assert.AreEqual(1000, actual);
        }

        [TestMethod]
        public void PrivateAccessor_ShouldCallPrivateStaticMethod()
        {
            // ACT
            // Wrapping the instance holding the private method by type.
            var inst = PrivateAccessor.ForType(typeof(ClassWithNonPublicMembers));
            // Calling the non-public static method by giving its exact name.
            var actual = inst.CallMethod("MeStaticPrivate");

            // ASSERT
            Assert.AreEqual(2000, actual);
        }

        [TestMethod]
        public void PrivateAccessor_ShouldGetSetProperty()
        {
            // ACT
            // Wrapping the instance holding the private property.
            var inst = new PrivateAccessor(new ClassWithNonPublicMembers());
            // Setting the value of the private property.
            inst.SetProperty("Prop", 555);

            // ASSERT - Asserting with getting the value of the private property.
            Assert.AreEqual(555, inst.GetProperty("Prop"));
        } 
    }

    #region SUT
    public class ClassWithNonPublicMembers
    {
        private int Prop { get; set; }

        private int MePrivate()
        {
            return 1000;
        }

        private static int MeStaticPrivate()
        {
            return 2000;
        }
    } 
    #endregion
}