如何对私有方法进行单元测试？

MS Test内置了一个很好的功能，通过创建一个名为VSCodeGenAccessors的文件，使得项目中的私有成员和方法可用。

[System.Diagnostics.DebuggerStepThrough()]
    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.TestTools.UnitTestGeneration", "1.0.0.0")]
    internal class BaseAccessor
    {

        protected Microsoft.VisualStudio.TestTools.UnitTesting.PrivateObject m_privateObject;

        protected BaseAccessor(object target, Microsoft.VisualStudio.TestTools.UnitTesting.PrivateType type)
        {
            m_privateObject = new Microsoft.VisualStudio.TestTools.UnitTesting.PrivateObject(target, type);
        }

        protected BaseAccessor(Microsoft.VisualStudio.TestTools.UnitTesting.PrivateType type)
            :
                this(null, type)
        {
        }

        internal virtual object Target
        {
            get
            {
                return m_privateObject.Target;
            }
        }

        public override string ToString()
        {
            return this.Target.ToString();
        }

        public override bool Equals(object obj)
        {
            if (typeof(BaseAccessor).IsInstanceOfType(obj))
            {
                obj = ((BaseAccessor)(obj)).Target;
            }
            return this.Target.Equals(obj);
        }

        public override int GetHashCode()
        {
            return this.Target.GetHashCode();
        }
    }

使用从BaseAccessor派生的类

例如：

[System.Diagnostics.DebuggerStepThrough()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.TestTools.UnitTestGeneration", "1.0.0.0")]
internal class SomeClassAccessor : BaseAccessor
{

    protected static Microsoft.VisualStudio.TestTools.UnitTesting.PrivateType m_privateType = new Microsoft.VisualStudio.TestTools.UnitTesting.PrivateType(typeof(global::Namespace.SomeClass));

    internal SomeClassAccessor(global::Namespace.Someclass target)
        : base(target, m_privateType)
    {
    }

    internal static string STATIC_STRING
    {
        get
        {
            string ret = ((string)(m_privateType.GetStaticField("STATIC_STRING")));
            return ret;
        }
        set
        {
            m_privateType.SetStaticField("STATIC_STRING", value);
        }
    }

    internal int memberVar    {
        get
        {
            int ret = ((int)(m_privateObject.GetField("memberVar")));
            return ret;
        }
        set
        {
            m_privateObject.SetField("memberVar", value);
        }
    }

    internal int PrivateMethodName(int paramName)
    {
        object[] args = new object[] {
            paramName};
        int ret = (int)(m_privateObject.Invoke("PrivateMethodName", new System.Type[] {
                typeof(int)}, args)));
        return ret;
    }

对于任何想要在没有烦恼和杂乱的情况下运行私有方法的人，这个方法可以与使用旧式反射 (Reflection) 的任何单元测试框架配合使用。

public class ReflectionTools
{
    // If the class is non-static
    public static Object InvokePrivate(Object objectUnderTest, string method, params object[] args)
    {
        Type t = objectUnderTest.GetType();
        return t.InvokeMember(method,
            BindingFlags.InvokeMethod |
            BindingFlags.NonPublic |
            BindingFlags.Instance |
            BindingFlags.Static,
            null,
            objectUnderTest,
            args);
    }
    // if the class is static
    public static Object InvokePrivate(Type typeOfObjectUnderTest, string method, params object[] args)
    {
        MemberInfo[] members = typeOfObjectUnderTest.GetMembers(BindingFlags.NonPublic | BindingFlags.Static);
        foreach(var member in members)
        {
            if (member.Name == method)
            {
                return typeOfObjectUnderTest.InvokeMember(method, BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.InvokeMethod, null, typeOfObjectUnderTest, args);
            }
        }
        return null;
    }
}

在你的实际测试中，你可以这样做：

Assert.AreEqual( 
  ReflectionTools.InvokePrivate(
    typeof(StaticClassOfMethod), 
    "PrivateMethod"), 
  "Expected Result");

Assert.AreEqual( 
  ReflectionTools.InvokePrivate(
    new ClassOfMethod(), 
    "PrivateMethod"), 
  "Expected Result");

在CodeProject上，有一篇文章简要讨论了测试私有方法的优缺点。它随后提供了一些反射代码来访问私有方法（类似于Marcus上面提供的代码）。我发现样例唯一的问题是代码没有考虑重载方法。
您可以在这里找到这篇文章：http://www.codeproject.com/KB/cs/testnonpublicmembers.aspx。

将它们声明为internal，然后使用InternalsVisibleToAttribute来允许您的单元测试程序集查看它们。

我不太喜欢使用编译器指令，因为它们会很快地使事情变得混乱。如果您真的需要使用它们，可以将它们放在部分类中，并在生成产品版本时让构建过程忽略该.cs文件以减轻影响。

有时，测试私有声明可能是有益的。 基本上，编译器只有一个公共方法：Compile（string outputFileName，params string [] sourceSFileNames）。我相信你明白，在不测试每个“隐藏”声明的情况下，要测试这样的方法将会很困难！
这就是为什么我们创建了Visual T#：以使测试更加容易。它是一个免费的.NET编程语言（与C# v2.0兼容）。
我们添加了'.-'运算符。它的行为与'.'运算符相同，除了您可以在不更改测试项目中的任何内容的情况下访问任何隐藏声明。
请访问我们的网站：下载它，免费。

我很惊讶还没有人提到这一点，但我采用的解决方案是在类内部创建一个静态方法来进行测试。这样可以访问所有公共和私有属性进行测试。
此外，在脚本语言（具有面向对象能力的语言，如Python、Ruby和PHP）中，您可以使文件在运行时自行测试。这是确保更改不会破坏任何内容的快速方法。这显然是测试所有类的可扩展解决方案：只需运行它们全部即可。（您还可以在其他语言中使用void main来始终运行其测试）。

首先，你不应该测试你的代码私有方法。你应该测试“公共接口”或API，即类的公共部分。API是你向外部调用方公开的所有公共方法。
原因是一旦你开始测试类的私有方法和内部细节，就会将类的实现（私有内容）与测试耦合在一起。这意味着当你决定更改实现细节时，你也必须更改测试。
因此，你应该避免使用InternalsVisibleToAttribute。
以下是Ian Cooper的一个很棒的演讲，涉及了这个主题：Ian Cooper: TDD, where did it all go wrong

CC -Dprivate=public

"CC"是我使用的系统上的命令行编译器。-Dfoo=bar的作用相当于#define foo bar。因此，这个编译选项有效地将所有私有内容更改为公共内容。

我希望在这里创建一个清晰的代码示例，您可以在任何需要测试私有方法的类中使用。

在您的测试用例类中只需包含这些方法，然后按照指示使用它们即可。

  /**
   *
   * @var Class_name_of_class_you_want_to_test_private_methods_in
   * note: the actual class and the private variable to store the 
   * class instance in, should at least be different case so that
   * they do not get confused in the code.  Here the class name is
   * is upper case while the private instance variable is all lower
   * case
   */
  private $class_name_of_class_you_want_to_test_private_methods_in;

  /**
   * This uses reflection to be able to get private methods to test
   * @param $methodName
   * @return ReflectionMethod
   */
  protected static function getMethod($methodName) {
    $class = new ReflectionClass('Class_name_of_class_you_want_to_test_private_methods_in');
    $method = $class->getMethod($methodName);
    $method->setAccessible(true);
    return $method;
  }

  /**
   * Uses reflection class to call private methods and get return values.
   * @param $methodName
   * @param array $params
   * @return mixed
   *
   * usage:     $this->_callMethod('_someFunctionName', array(param1,param2,param3));
   *  {params are in
   *   order in which they appear in the function declaration}
   */
  protected function _callMethod($methodName, $params=array()) {
    $method = self::getMethod($methodName);
    return $method->invokeArgs($this->class_name_of_class_you_want_to_test_private_methods_in, $params);
  }

$this->_callMethod('_someFunctionName', array(param1,param2,param3));

只需按照原始私有函数中参数的顺序发出参数即可。