Làm thế nào để bạn đơn vị thử nghiệm phương pháp riêng tư?

Tôi đang xây dựng một thư viện lớp sẽ có một số phương thức công khai & riêng tư. Tôi muốn có thể đơn vị kiểm tra các phương thức riêng tư (chủ yếu là trong khi phát triển, nhưng nó cũng có thể hữu ích cho việc tái cấu trúc trong tương lai).

cách chính xác để làm điều này là gì?

Nếu bạn đang sử dụng .net, bạn nên sử dụng InternalsVisibleToAttribution .

Nếu bạn muốn đơn vị kiểm tra một phương thức riêng tư, một cái gì đó có thể sai. Các bài kiểm tra đơn vị (nói chung) có nghĩa là để kiểm tra giao diện của một lớp, nghĩa là các phương thức công khai (và được bảo vệ) của nó. Tất nhiên bạn có thể "hack" một giải pháp cho vấn đề này (ngay cả khi chỉ bằng cách công khai các phương thức), nhưng bạn cũng có thể muốn xem xét:

1. Nếu phương pháp bạn muốn thử nghiệm thực sự đáng để thử nghiệm, thì có thể đáng để chuyển nó vào lớp của chính nó.
2. Thêm nhiều thử nghiệm vào các phương thức công khai gọi phương thức riêng, kiểm tra chức năng của phương thức riêng. .

Nó có thể không hữu ích để kiểm tra các phương pháp riêng tư. Tuy nhiên, đôi khi tôi cũng thích gọi các phương thức riêng tư từ các phương thức thử nghiệm. Hầu hết thời gian để ngăn chặn việc sao chép mã để tạo dữ liệu thử nghiệm ...

Microsoft cung cấp hai cơ chế cho việc này:

Phụ kiện

• Xem mã nguồn của định nghĩa lớp
• Nhấp chuột phải vào tên của lớp
• Chọn "Tạo truy cập riêng"
• Chọn dự án trong đó trình truy cập sẽ được tạo => Bạn sẽ kết thúc với một lớp mới với tên foo_accessor. Lớp này sẽ được tạo động trong quá trình biên dịch và cung cấp cho tất cả các thành viên công khai.

Tuy nhiên, cơ chế đôi khi hơi khó hiểu khi thay đổi giao diện của lớp gốc. Vì vậy, hầu hết các lần tôi tránh sử dụng này.

Lớp PrivateObject Cách khác là sử dụng Microsoft.VisualStudio.TestTools.UnitTesting.PrivateObject

// Wrap an already existing instance
PrivateObject accessor = new PrivateObject( objectInstanceToBeWrapped );

// Retrieve a private field
MyReturnType accessiblePrivateField = (MyReturnType) accessor.GetField( "privateFieldName" );

// Call a private method
accessor.Invoke( "PrivateMethodName", new Object[] {/* ... */} );

Tôi không đồng ý với triết lý "bạn chỉ nên quan tâm đến việc thử nghiệm giao diện bên ngoài". Nó giống như nói rằng một cửa hàng sửa chữa ô tô chỉ nên có các bài kiểm tra để xem nếu bánh xe quay. Vâng, cuối cùng tôi quan tâm đến hành vi bên ngoài nhưng tôi thích các bài kiểm tra nội bộ, riêng tư của riêng tôi để cụ thể hơn một chút và đi vào vấn đề. Có, nếu tôi tái cấu trúc, tôi có thể phải thay đổi một số thử nghiệm, nhưng trừ khi đó là một công cụ tái cấu trúc lớn, tôi sẽ chỉ phải thay đổi một số và thực tế là các thử nghiệm nội bộ khác (không thay đổi) vẫn hoạt động là một chỉ số tuyệt vời tái cấu trúc đã thành công.

Bạn có thể cố gắng bao gồm tất cả các trường hợp nội bộ chỉ sử dụng giao diện công cộng và về mặt lý thuyết có thể kiểm tra mọi phương thức nội bộ (hoặc ít nhất là mọi vấn đề) hoàn toàn bằng cách sử dụng giao diện công cộng nhưng cuối cùng bạn phải đứng trên đầu để đạt được điều này và kết nối giữa các trường hợp thử nghiệm được chạy qua giao diện công cộng và phần bên trong của giải pháp mà chúng được thiết kế để kiểm tra có thể khó hoặc không thể nhận ra. Đã chỉ ra, các thử nghiệm riêng lẻ đảm bảo rằng bộ máy bên trong hoạt động tốt cũng xứng đáng với những thay đổi thử nghiệm nhỏ xảy ra với tái cấu trúc - ít nhất đó là kinh nghiệm của tôi. Nếu bạn phải thực hiện các thay đổi lớn cho các thử nghiệm của mình cho mỗi lần tái cấu trúc, thì có thể điều này không có ý nghĩa gì, nhưng trong trường hợp đó, có lẽ bạn nên suy nghĩ lại về thiết kế của mình.

Trong những trường hợp hiếm hoi tôi muốn kiểm tra các chức năng riêng tư, tôi thường sửa đổi chúng để được bảo vệ thay vào đó và tôi đã viết một lớp con với chức năng bao bọc công khai.

Lớp:

...

protected void APrivateFunction()
{
    ...
}

...

Phân lớp để kiểm tra:

...

[Test]
public void TestAPrivateFunction()
{
    APrivateFunction();
    //or whatever testing code you want here
}

...

Tôi nghĩ rằng một câu hỏi cơ bản hơn nên được đặt ra là tại sao bạn lại cố gắng thử nghiệm phương pháp riêng tư ngay từ đầu. Đó là một mùi mã mà bạn đang cố kiểm tra phương thức riêng tư thông qua giao diện chung của lớp đó trong khi phương thức đó là riêng tư vì đó là một chi tiết triển khai. Người ta chỉ nên quan tâm đến hành vi của giao diện công cộng chứ không phải về cách nó được triển khai dưới vỏ bọc.

Nếu tôi muốn kiểm tra hành vi của phương thức riêng tư, bằng cách sử dụng các phép tái cấu trúc thông thường, tôi có thể trích xuất mã của nó sang một lớp khác (có thể với mức độ hiển thị của gói để đảm bảo nó không phải là một phần của API công khai). Sau đó tôi có thể kiểm tra hành vi của nó trong sự cô lập.

Sản phẩm của tái cấu trúc có nghĩa là phương thức riêng tư bây giờ là một lớp riêng biệt đã trở thành cộng tác viên của lớp ban đầu. Hành vi của nó sẽ trở nên được hiểu rõ thông qua các bài kiểm tra đơn vị của chính nó.

Sau đó tôi có thể chế giễu hành vi của nó khi tôi thử kiểm tra lớp ban đầu để sau đó tôi có thể tập trung kiểm tra hành vi của giao diện chung của lớp đó thay vì phải kiểm tra một vụ nổ kết hợp của giao diện công cộng và hành vi của tất cả các phương thức riêng tư của nó .

Tôi thấy điều này tương tự như lái xe hơi. Khi tôi lái xe, tôi không lái xe với nắp ca-pô để tôi có thể thấy rằng động cơ đang hoạt động. Tôi dựa vào giao diện mà chiếc xe cung cấp, cụ thể là bộ đếm vòng quay và đồng hồ tốc độ để biết động cơ đang hoạt động. Tôi dựa vào thực tế là chiếc xe thực sự di chuyển khi tôi nhấn bàn đạp ga. Nếu tôi muốn kiểm tra động cơ, tôi có thể kiểm tra nó một cách cô lập. : D

Tất nhiên việc thử nghiệm các phương thức riêng tư trực tiếp có thể là giải pháp cuối cùng nếu bạn có một ứng dụng cũ nhưng tôi thích mã kế thừa đó được cấu trúc lại để cho phép thử nghiệm tốt hơn. Michael Feathers đã viết một cuốn sách tuyệt vời về chính chủ đề này. http://www.amazon.co.uk/Working-Effectively-Legacy-Robert-Martin/dp/0131177052

Các loại riêng tư, nội bộ và thành viên riêng là vì một số lý do và thường bạn không muốn gây rối trực tiếp với họ. Và nếu bạn làm như vậy, rất có thể bạn sẽ phá vỡ sau này, bởi vì không có gì đảm bảo rằng những kẻ đã tạo ra các hội đồng đó sẽ giữ các triển khai riêng tư / nội bộ như vậy.

Nhưng, đôi khi, khi thực hiện một số hack / thăm dò các hội đồng biên dịch hoặc bên thứ ba, cuối cùng tôi đã muốn khởi tạo một lớp riêng hoặc một lớp với một nhà xây dựng riêng hoặc nội bộ. Hoặc, đôi khi, khi xử lý các thư viện kế thừa được biên dịch trước mà tôi không thể thay đổi - tôi cuối cùng đã viết một số thử nghiệm theo phương pháp riêng tư.

Do đó, sinh ra AccessPrivateWrapper - http://amazedsaint.blogspot.com/2010/05/accessprivatewrapper-c-40-dynamic.html - đây là lớp trình bao bọc nhanh giúp công việc dễ dàng sử dụng các tính năng và phản xạ động C # 4.0.

Bạn có thể tạo các loại nội bộ / riêng tư như

    //Note that the wrapper is dynamic
    dynamic wrapper = AccessPrivateWrapper.FromType
        (typeof(SomeKnownClass).Assembly,"ClassWithPrivateConstructor");

    //Access the private members
    wrapper.PrivateMethodInPrivateClass();

Vâng, bạn có thể đơn vị kiểm tra phương pháp riêng tư theo hai cách

1. bạn có thể tạo thể hiện của PrivateObjectlớp cú pháp như sau

   PrivateObject obj= new PrivateObject(PrivateClass);
   //now with this obj you can call the private method of PrivateCalss.
   obj.PrivateMethod("Parameters");

2. Bạn có thể sử dụng sự phản chiếu.

   PrivateClass obj = new PrivateClass(); // Class containing private obj
   Type t = typeof(PrivateClass); 
   var x = t.InvokeMember("PrivateFunc", 
       BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Public |  
           BindingFlags.Instance, null, obj, new object[] { 5 });

Tôi cũng đã sử dụng phương thức InternalsVisibleToAttribution. Điều đáng nói là, nếu bạn cảm thấy không thoải mái khi đặt các phương thức riêng tư trước đây của mình để đạt được điều này, thì có lẽ chúng không phải là đối tượng của các bài kiểm tra đơn vị trực tiếp.

Rốt cuộc, bạn đang kiểm tra hành vi của lớp, thay vì thực hiện cụ thể - bạn có thể thay đổi cái sau mà không thay đổi cái trước và các bài kiểm tra của bạn vẫn sẽ vượt qua.

Có 2 loại phương pháp riêng. Phương thức riêng tư tĩnh và phương pháp riêng không tĩnh (Phương pháp sơ thẩm). 2 bài viết sau đây giải thích cách kiểm tra các phương thức riêng tư bằng các ví dụ.

1. Kiểm thử đơn vị Phương pháp riêng tĩnh
2. Kiểm thử đơn vị Phương pháp riêng không tĩnh

MS Test có một tính năng hay được tích hợp trong đó giúp các thành viên và phương thức riêng tư có sẵn trong dự án bằng cách tạo một tệp có tên 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();
        }
    }

Với các lớp xuất phát từ BaseAccessor

nhu la

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

Trên CodeProject, có một bài viết thảo luận ngắn gọn về ưu và nhược điểm của việc thử nghiệm các phương thức riêng tư. Sau đó, nó cung cấp một số mã phản chiếu để truy cập các phương thức riêng tư (tương tự như mã mà Marcus cung cấp ở trên.) Vấn đề duy nhất tôi tìm thấy với mẫu là mã không tính đến các phương thức quá tải.

Bạn có thể tìm thấy bài viết ở đây:

http://www.codeproject.com/KB/cs/testnonpublicmembers.aspx

Khai báo chúng internal, và sau đó sử dụng InternalsVisibleToAttributeđể cho phép lắp ráp thử nghiệm đơn vị của bạn để xem chúng.

Tôi có xu hướng không sử dụng các chỉ thị của trình biên dịch vì chúng làm lộn xộn mọi thứ một cách nhanh chóng. Một cách để giảm thiểu nó nếu bạn thực sự cần chúng là đặt chúng trong một lớp một phần và bản dựng của bạn bỏ qua tệp .cs đó khi tạo phiên bản sản xuất.

Bạn không nên thử nghiệm các phương thức riêng tư của mã của bạn ở nơi đầu tiên. Bạn nên kiểm tra 'giao diện công cộng' hoặc API, những thứ công khai trong các lớp học của bạn. API là tất cả các phương thức công khai mà bạn đưa ra cho những người gọi bên ngoài.

Lý do là một khi bạn bắt đầu thử nghiệm các phương thức riêng tư và nội bộ của lớp, bạn sẽ kết hợp việc thực hiện lớp của bạn (những thứ riêng tư) với các bài kiểm tra của bạn. Điều này có nghĩa là khi bạn quyết định thay đổi chi tiết thực hiện, bạn cũng sẽ phải thay đổi các bài kiểm tra của mình.

Vì lý do này, bạn nên tránh sử dụng InternalsVisibleToAtrribution.

Đây là một bài nói chuyện tuyệt vời của Ian Cooper bao gồm chủ đề này: Ian Cooper: TDD, nơi mà tất cả đã đi sai

Đôi khi, nó có thể là tốt để kiểm tra khai báo tư nhân. Về cơ bản, trình biên dịch chỉ có một phương thức công khai: Biên dịch (chuỗi outputFileName, chuỗi params [] sourceSFileNames). Tôi chắc rằng bạn hiểu rằng sẽ khó kiểm tra một phương pháp như vậy nếu không kiểm tra từng khai báo "ẩn"!

Đó là lý do tại sao chúng tôi đã tạo ra Visual T #: để ​​thực hiện các bài kiểm tra dễ dàng hơn. Đó là ngôn ngữ lập trình .NET miễn phí (tương thích C # v2.0).

Chúng tôi đã thêm toán tử '.-'. Nó chỉ hành xử như '.' toán tử, ngoại trừ bạn cũng có thể truy cập bất kỳ khai báo ẩn nào từ các thử nghiệm của mình mà không thay đổi bất cứ điều gì trong dự án được thử nghiệm của bạn.

Hãy xem tại trang web của chúng tôi: tải nó miễn phí .

Tôi ngạc nhiên chưa ai nói điều này, nhưng một giải pháp tôi đã sử dụng là tạo ra một phương thức tĩnh bên trong lớp để tự kiểm tra. Điều này cho phép bạn truy cập vào mọi thứ công khai và riêng tư để kiểm tra.

Hơn nữa, trong một ngôn ngữ kịch bản (với các khả năng OO, như Python, Ruby và PHP), bạn có thể tự kiểm tra tệp khi chạy. Cách nhanh chóng tốt đẹp để đảm bảo thay đổi của bạn đã không phá vỡ bất cứ điều gì. Điều này rõ ràng tạo ra một giải pháp có thể mở rộng để kiểm tra tất cả các lớp của bạn: chỉ cần chạy tất cả chúng. (bạn cũng có thể thực hiện việc này bằng các ngôn ngữ khác với khoảng trống chính luôn chạy các bài kiểm tra của nó).

Tôi muốn tạo một ví dụ mã rõ ràng ở đây mà bạn có thể sử dụng trên bất kỳ lớp nào mà bạn muốn kiểm tra phương thức riêng tư.

Trong trường hợp thử nghiệm của bạn, chỉ bao gồm các phương thức này và sau đó sử dụng chúng như được chỉ định.

  /**
   *
   * @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', mảng (param1, param2, param3));

Chỉ cần đưa ra các tham số theo thứ tự xuất hiện trong hàm riêng ban đầu

Đối với bất cứ ai muốn chạy các phương thức riêng tư mà không cần tất cả các fess và lộn xộn. Điều này hoạt động với bất kỳ khung thử nghiệm đơn vị nào sử dụng không có gì ngoài Reflection cũ tốt.

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

Sau đó, trong các thử nghiệm thực tế của bạn, bạn có thể làm một cái gì đó như thế này:

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

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

MbUnit có một trình bao bọc đẹp cho cái này được gọi là Reflector.

Reflector dogReflector = new Reflector(new Dog());
dogReflector.Invoke("DreamAbout", DogDream.Food);

Bạn cũng có thể đặt và nhận các giá trị từ các thuộc tính

dogReflector.GetProperty("Age");

Về "thử nghiệm riêng tư" tôi đồng ý rằng .. trong thế giới hoàn hảo. không có điểm nào trong việc làm bài kiểm tra đơn vị tư nhân. Nhưng trong thế giới thực, bạn có thể sẽ muốn viết các bài kiểm tra riêng thay vì tái cấu trúc mã.

Đây là bài viết tốt về thử nghiệm đơn vị của các phương pháp riêng tư. Nhưng tôi không chắc những gì tốt hơn, để làm cho ứng dụng của bạn được thiết kế đặc biệt để thử nghiệm (nó giống như tạo các thử nghiệm chỉ để thử nghiệm) hoặc sử dụng phản xạ để thử nghiệm. Khá chắc chắn rằng hầu hết chúng ta sẽ chọn cách thứ hai.

Theo tôi, bạn chỉ nên kiểm tra API công khai của bạn.

Công khai một phương thức, để đơn vị kiểm tra nó, phá vỡ đóng gói phơi bày chi tiết thực hiện.

API công khai tốt sẽ giải quyết mục tiêu ngay lập tức của mã máy khách và giải quyết hoàn toàn mục tiêu đó.

Tôi sử dụng lớp PrivateObject . Nhưng như đã đề cập trước đây tốt hơn để tránh thử nghiệm các phương pháp riêng tư.

Class target = new Class();
PrivateObject obj = new PrivateObject(target);
var retVal = obj.Invoke("PrivateMethod");
Assert.AreEqual(retVal);

CC -Dprivate=public

"CC" là trình biên dịch dòng lệnh trên hệ thống tôi sử dụng. -Dfoo=barkhông tương đương với #define foo bar. Vì vậy, tùy chọn biên dịch này có hiệu quả thay đổi tất cả các công cụ riêng tư thành công khai.

Đây là một ví dụ, đầu tiên là chữ ký phương thức:

private string[] SplitInternal()
{
    return Regex.Matches(Format, @"([^/\[\]]|\[[^]]*\])+")
                        .Cast<Match>()
                        .Select(m => m.Value)
                        .Where(s => !string.IsNullOrEmpty(s))
                        .ToArray();
}

Đây là bài kiểm tra:

/// <summary>
///A test for SplitInternal
///</summary>
[TestMethod()]
[DeploymentItem("Git XmlLib vs2008.dll")]
public void SplitInternalTest()
{
    string path = "pair[path/to/@Key={0}]/Items/Item[Name={1}]/Date";
    object[] values = new object[] { 2, "Martin" };
    XPathString xp = new XPathString(path, values);

    PrivateObject param0 = new PrivateObject(xp);
    XPathString_Accessor target = new XPathString_Accessor(param0);
    string[] expected = new string[] {
        "pair[path/to/@Key={0}]",
        "Items",
        "Item[Name={1}]",
        "Date"
    };
    string[] actual;
    actual = target.SplitInternal();
    CollectionAssert.AreEqual(expected, actual);
}

Một cách để làm điều này là có phương thức của bạn protectedvà viết một lịch thi thử kế thừa lớp của bạn để được kiểm tra. Bằng cách này, bạn cũng không chuyển phương thức của mình public, nhưng bạn cho phép thử nghiệm.

1) Nếu bạn có mã kế thừa thì cách duy nhất để kiểm tra các phương thức riêng là phản xạ.

2) Nếu đó là mã mới thì bạn có các tùy chọn sau:

• Sử dụng sự phản chiếu (để phức tạp)
• Viết kiểm thử đơn vị trong cùng một lớp (làm cho mã sản xuất trở nên xấu xí bằng cách có mã kiểm tra trong đó)
• Tái cấu trúc và làm cho phương thức được công khai trong một số loại lớp sử dụng
• Sử dụng chú thích @VisibleForTesting và xóa riêng tư

Tôi thích phương pháp chú thích, đơn giản nhất và ít phức tạp nhất. Vấn đề duy nhất là chúng tôi đã tăng khả năng hiển thị mà tôi nghĩ không phải là mối quan tâm lớn. Chúng ta phải luôn luôn mã hóa giao diện, vì vậy nếu chúng ta có giao diện MyService và triển khai MyServiceImpl thì chúng ta có thể có các lớp kiểm tra tương ứng đó là MyServiceTest (phương thức giao diện thử nghiệm) và MyServiceImplTest (phương thức kiểm tra riêng tư). Tất cả các máy khách dù sao cũng nên sử dụng giao diện, theo một cách nào đó, mặc dù khả năng hiển thị của phương thức riêng tư đã tăng lên nhưng điều đó không thực sự quan trọng.

Bạn cũng có thể khai báo nó là công khai hoặc nội bộ (với InternalsVisibleToAttribution) trong khi xây dựng ở chế độ gỡ lỗi:

    /// <summary>
    /// This Method is private.
    /// </summary>
#if DEBUG
    public
#else
    private
#endif
    static string MyPrivateMethod()
    {
        return "false";
    }

Nó làm mờ mã, nhưng nó sẽ privateở trong bản phát hành.

Bạn có thể tạo phương thức thử nghiệm cho phương thức riêng tư từ Visual studio 2008. Khi bạn tạo một thử nghiệm đơn vị cho một phương thức riêng tư, một thư mục Tham khảo thử nghiệm được thêm vào dự án thử nghiệm của bạn và một trình truy cập được thêm vào thư mục đó. Bộ truy cập cũng được tham chiếu trong logic của phương pháp thử nghiệm đơn vị. Trình truy cập này cho phép kiểm tra đơn vị của bạn gọi các phương thức riêng tư trong mã mà bạn đang kiểm tra. Để biết chi tiết hãy xem

http://msdn.microsoft.com/en-us/l Library / bb385974.aspx

Cũng lưu ý rằng InternalsVisibleToAtrribution có yêu cầu rằng hội đồng của bạn phải được đặt tên mạnh , điều này tạo ra một loạt vấn đề nếu bạn làm việc trong một giải pháp chưa có yêu cầu đó trước đó. Tôi sử dụng accessor để kiểm tra các phương thức riêng tư. Xem câu hỏi này cho một ví dụ về điều này.