एफ # में आप xUnit की इनलाइनडेटा विशेषता

Question

पर संग्रह कैसे पास करते हैं, मैं xUnit's InlineData के पैरामीटर के रूप में एक सूची, सरणी और/या seq का उपयोग करना चाहता हूं।

सी # में मैं यह कर सकता:

using Xunit; //2.1.0 

namespace CsTests 
{ 
    public class Tests 
    { 
     [Theory] 
     [InlineData(new[] {1, 2})] 
     public void GivenCollectionItMustPassItToTest(int[] coll) 
     { 
      Assert.Equal(coll, coll); 
     } 
    } 
} 

एफ # में मैं इस है:

namespace XunitTests 

module Tests = 
    open Xunit //2.1.0 

    [<Theory>] 
    [<InlineData(8)>] 
    [<InlineData(42)>] 
    let ``given a value it must give it to the test`` (value : int) = 
    Assert.Equal(value, value) 

    [<Theory>] 
    [<InlineData([1; 2])>] 
    let ``given a list it should be able to pass it to the test`` 
    (coll : int list) = 
    Assert.Equal<int list>(coll, coll) 

    [<Theory>] 
    [<InlineData([|3; 4|])>] 
    let ``given an array it should be able to pass it to the test`` 
    (coll : int array) = 
    Assert.Equal<int array>(coll, coll) 

एफ # कोड निम्नलिखित निर्माण त्रुटियों दे:

Library1.fs (13, 16): यह मान्य निरंतर अभिव्यक्ति या कस्टम विशेषता मान

नहीं है

Library1.fs (18, 16): यह एक वैध निरंतर अभिव्यक्ति या कस्टम नहीं है विशेषता मान

2 और 3 परीक्षण सिद्धांतों की चर्चा करते हुए।

क्या इनलाइनडेटा विशेषता में संग्रह में पास करने के लिए xUnit का उपयोग करना संभव है?

Answer 1

InlineDataAttribute सी # params तंत्र पर leans। यह वही है सी # में InlineData के डिफ़ॉल्ट वाक्य रचना के लिए सक्षम बनाता है: -

[InlineData(1,2)] 

सरणी निर्माण के साथ आपका संस्करण: -

[InlineData(new object[] {1,2})] 

क्या संकलक ऊपर करने के लिए अनुवाद बस है। जिस मिनट में आप आगे जाते हैं, आप उसी प्रतिबंध में भाग लेंगे जो सीएलआई वास्तव में सक्षम होगा - नीचे की रेखा यह है कि आईएल स्तर पर, विशेषता रचनाकारों का उपयोग करने का तात्पर्य है कि संकलन समय पर सबकुछ स्थिरांक तक उबाला जाना चाहिए।[<InlineData(1,2)>] है, तो आपके सवाल का सीधा जवाब है: ऊपर वाक्य रचना के एफ # बराबर बस है

module UsingInlineData = 
    [<Theory>] 
    [<InlineData(1, 2)>] 
    [<InlineData(1, 1)>] 
    let v4 (a : int, b : int) : unit = Assert.NotEqual(a, b) 

---

मैं @ bytebuster के उदाहरण पर riffing से बचने के लिए, हालांकि :) अगर हम एक सहायक को परिभाषित असमर्थ था: -

type ClassDataBase(generator : obj [] seq) = 
    interface seq<obj []> with 
     member this.GetEnumerator() = generator.GetEnumerator() 
     member this.GetEnumerator() = 
      generator.GetEnumerator() :> System.Collections.IEnumerator 

फिर (यदि हम आलस्य छोड़ करने को तैयार हैं), हम list दुरुपयोग seq/yield कोड गोल्फ जीतने के लिए उपयोग करने के लिए होने से बचने के लिए कर सकते हैं: -

type MyArrays1() = 
    inherit ClassDataBase([ [| 3; 4 |]; [| 32; 42 |] ]) 

[<Theory>] 
[<ClassData(typeof<MyArrays1>)>] 
let v1 (a : int, b : int) : unit = Assert.NotEqual(a, b) 

लेकिन seq के कच्चे वाक्य रचना पर्याप्त स्वच्छ बनाया जा सकता है, तो के रूप में ऊपर के लिए इसका इस्तेमाल करने के लिए कोई वास्तविक आवश्यकता है, इसके बजाय हम करते हैं:

let values : obj array seq = 
    seq { 
     yield [| 3; 4 |] 
     yield [| 32; 42 |] 
    } 

type ValuesAsClassData() = 
    inherit ClassDataBase(values) 

[<Theory; ClassData(typeof<ValuesAsClassData>)>] 
let v2 (a : int, b : int) : unit = Assert.NotEqual(a, b) 

---

हालांकि, ज्यादातर मेरे लिए XUnit v2 के साथ मुहावरेदार सीधे MemberData का उपयोग (जो XUnit v1 के PropertyData की तरह है, लेकिन सामान्यीकृत भी खेतों पर काम करने के लिए) के लिए है: -

[<Theory; MemberData("values")>] 
let v3 (a : int, b : int) : unit = Assert.NotEqual(a, b) 

कुंजी सही होने की बात यह है कि अनुक्रम की घोषणा पर : seq<obj> (या : obj array seq) डालें या xUnit आपको फेंक देगा।

Answer 2

जैसा कि this question में वर्णित है, आप केवल InlineData के साथ अक्षर का उपयोग कर सकते हैं। सूची अक्षर नहीं हैं।

हालांकि, xUnit ClassData प्रदान करता है जो आपको लगता है कि ऐसा करने के लिए लगता है।

This question सी # के लिए एक ही समस्या पर चर्चा करता है।

आदेश परीक्षण के साथ ClassData उपयोग करने के लिए, बस एक डेटा वर्ग को लागू करने seq<obj[]> बनाने में:

type MyArrays() =  
    let values : seq<obj[]> = 
     seq { 
      yield [|3; 4|] // 1st test case 
      yield [|32; 42|] // 2nd test case, etc. 
     } 
    interface seq<obj[]> with 
     member this.GetEnumerator() = values.GetEnumerator() 
     member this.GetEnumerator() = 
      values.GetEnumerator() :> System.Collections.IEnumerator 

module Theories = 
    [<Theory>] 
    [<ClassData(typeof<MyArrays1>)>] 
    let ``given an array it should be able to pass it to the test`` (a : int, b : int) : unit = 
     Assert.NotEqual(a, b) 

इस यद्यपि कुछ मैनुअल कोडिंग की आवश्यकता है, तो आप डेटा वर्ग, जिसमें उपयोगी प्रतीत होता है फिर से उपयोग कर सकते हैं वास्तविक जीवन परियोजनाएं, जहां हम अक्सर एक ही डेटा के खिलाफ अलग-अलग परीक्षण चलाते हैं।