In F# how do you pass a collection to xUnit's InlineData attribute

Question

I would like to be about to use a list, array, and/or seq as a parameter to xUnit's InlineData.

In C# I can do this:

using Xunit; //2.1.0

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

In F# I have this:

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)

The F# code give the following build errors:

Library1.fs (13, 16): This is not a valid constant expression or custom attribute value

Library1.fs (18, 16): This is not a valid constant expression or custom attribute value

Referring to the 2nd and 3rd test theories.

Is it possible to use xUnit to pass in collections to the InlineData attribute?

Thanks James, if that is the case how do people normally hand needing a collection for test data in F#? — Mike Harris, Jan 27 '16 at 01:05
I'd suggested this is a duplicate of http://stackoverflow.com/questions/29349152/cannot-create-list-literal-in-f. However that question is specifically how to create a literal list in F# (and the answer is: you can't). This question is "How can I use xUnit and pass in a list of test data". Looks like @bytebuster has a workable answer. — James Hugard, Jan 27 '16 at 02:35
You can't use lists, but you ought to be able to use arrays like in C#, but I've never been able to make it compile. Fortunately, this becomes irrelevant once you discover [FsCheck.Xunit](https://fscheck.github.io/FsCheck/RunningTests.html). — Mark Seemann, Jan 27 '16 at 06:40
@MarkSeemann thanks. I was hoping there was a solution for example based testing, but maybe I need to use property based testing more. — Mike Harris, Jan 27 '16 at 11:45
This question shows other ways of achieving the same goal https://stackoverflow.com/questions/22093843/pass-complex-parameters-to-theory — Simon_Weaver, Dec 29 '18 at 20:15

Ruben Bartelink · Accepted Answer · 2020-05-05T06:33:08.130

InlineDataAttribute leans on the C# params mechanism. This is what enables the default syntax of InlineData in C# :-

[InlineData(1,2)]

Your version with array construction:-

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

is simply what the compiler translates the above into. The minute you go further, you'll run into the same restrictions on what the CLI will actually enable - the bottom line is that at the IL level, using attribute constructors implies that everything needs to be boiled down to constants at compile time. The F# equivalent of the above syntax is simply: [<InlineData(1,2)>], so the direct answer to your question is:

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

I was unable to avoid riffing on @bytebuster's example though :) If we define a helper:-

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

Then (if we are willing to forgo laziness), we can abuse list to avoid having to use seq / yield to win the code golf:-

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

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

But the raw syntax of seq can be made sufficiently clean, so no real need to use it as above, instead we do:

let values : obj[] seq = 
    seq { 
        yield [| 3; 4 |] 
        yield [| 32; 42 |] // in recent versions of F#, `yield` is optional in seq too
    }

type ValuesAsClassData() = 
    inherit ClassDataBase(values)

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

However, most idiomatic with xUnit v2 for me is to use straight MemberData (which is like xUnit v1's PropertyData but generalized to also work on fields) :-

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

The key thing to get right is to put the : seq<obj> (or : obj[] seq) on the declaration of the sequence or xUnit will throw at you.

Later versions of xUnit 2 include a typed TheoryData, which lets you write:

type Values() as this =
    inherit TheoryData<int,int>()
    do  this.Add(3, 4)
        this.Add(32, 42)

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

That also type-checks each argument.

Thanks this works, but NCrunch does not seem to like MemberData. O-well, I'll most likely either use a Fact or FsCheck going forward. — Mike Harris, Feb 02 '16 at 23:50
Is it `Theory` or `MemberData` it doesnt like? If its the latter, then you should be able to make `PropertyData` work - just add `with get()` to the field? You're right about having ample substitutes - in general it's easy enough to make each leg of a Theory an individually addressable Fact and probably end up with more readable code. — Ruben Bartelink, Feb 03 '16 at 09:03

score 10 · Answer 2 · edited May 23 '17 at 11:44

10

As described in this question, you can only use literals with InlineData. Lists are not literals.

However, xUnit provides with ClassData which seems to do what you need.

This question discusses the same problem for C#.

In order to use ClassData with the tests, just make a data class implementing 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)

Albeit this requires some manual coding, you may re-use the data class, which appears to be useful in real-life projects, where we often run different tests against the same data.

edited May 23 '17 at 11:44

Community

1
1

answered Jan 27 '16 at 01:50

Be Brave Be Like Ukraine

7,596
3
42
66

I cannot get this solution to work as is, but I see where you are going and believe this the "correct" answer. Thank you I will make it as correct once I get it to work. – Mike Harris Jan 27 '16 at 11:43
1

The seq { [|3; 4|] [|32; 43|] } is not a valid seq expression, I ended up using type MyArrays () = let values = seq [ [|3; 4|] // 1st test case [|32; 42|] // 2nd test case, etc. ] |> Seq.cast interface seq with member this.GetEnumerator<'T> () = values.GetEnumerator() :> System.Collections.Generics.IEnumerator<'T> member this.GetEnumerator () = values.GetEnumerator() :> System.Collections.IEnumerator – Mike Harris Jan 28 '16 at 00:37
1

@MikeHarris You are correct in your suppositions, I've edited in two missing yield operators and a type mistake [And an answer expanding on all this below] – Ruben Bartelink Feb 01 '16 at 13:19

score 6 · Answer 3 · edited Feb 15 '20 at 11:48

6

You can also use the member data without class:

let memberDataProperty = seq {
    yield [|"param1":> Object; param2 :> Object; expectedResult :> Object |]
}

[<Theory; MemberData("memberDataProperty")>]
let ``Can use MemberData`` param1 param2 expectedResult = ...

edited Feb 15 '20 at 11:48

Ruben Bartelink

59,778
26
187
249

answered Dec 18 '18 at 22:58

Assassin

1,296
2
14
17

nice - some tweaks 1) you can use `box` instead of `:> Object` 2) if using F# 4.7, you can use nameof to derive `"memberDataProperty"` – Ruben Bartelink Feb 15 '20 at 11:49

score 5 · Answer 4 · answered Jun 18 '18 at 08:07

You can use the FSharp.Reflection namespace to good effect here. Consider some hypothetical function isAnswer : (string -> int -> bool) that you want to test with a few examples.

Here's one way:

open FSharp.Reflection
open Xunit

type TestData() =
  static member MyTestData =
    [ ("smallest prime?", 2, true)
      ("how many roads must a man walk down?", 41, false) 
    ] |> Seq.map FSharpValue.GetTupleFields

[<Theory; MemberData("MyTestData", MemberType=typeof<TestData>)>]
let myTest (q, a, expected) =
  Assert.Equals(isAnswer q a, expected)

The key thing is the |> Seq.map FSharpValue.GetTupleFields line. It takes the list of tuples (you have to use tuples to allow different arguments types) and transforms it to the IEnumerable<obj[]> that XUnit expects.

Tyson Williams · Answer 5 · 2019-07-31T18:27:39.537

One possibility is to use xUnit's MemberData attribute. A disadvantage with this approach is that this parameterized test appears in Visual Studio's Test Explorer as one test instead of two separate tests because collections lack xUnit's IXunitSerializable interface and xUnit hasn't added build-in serialization support for that type either. See xunit/xunit/issues/429 for more information.

Here is a minimal working example.

module TestModule

  open Xunit

  type TestType () =
    static member TestProperty
      with get() : obj[] list =
        [
          [| [0]; "a" |]
          [| [1;2]; "b" |]
        ]

    [<Theory>]
    [<MemberData("TestProperty")>]            
    member __.TestMethod (a:int list) (b:string) =
      Assert.Equal(1, a.Length)

See also this similar question in which I give a similar answer.

score 3 · Answer 6 · answered Jan 23 '20 at 21:52

Building further on @Assassin's brilliant answer -- now we have implicit yields you can put the test cases in an array and dispense with the yields. I would also be tempted to add a cheeky little private operator to handle the object conversions. Thus:

open System
open Xunit

let inline private (~~) x = x :> Object

let degreesToRadiansCases =
    [|
        // Degrees; Radians
        [|   ~~0.0;            ~~0.0  |]
        [| ~~360.0; ~~(Math.PI * 2.0) |]
    |]

[<Theory>]
[<MemberData("degreesToRadiansCases")>]
let ``Convert from degrees to radians`` (degrees, radians) =
    let expected = radians
    let actual = Geodesy.Angle.toRadians degrees
    Assert.Equal(expected, actual)

let stringCases =
    [|
        [| ~~99; ~~"hello1" |] 
        [| ~~99; ~~"hello2" |] 
    |]

[<Theory>]
[<MemberData("stringCases")>]
let ``tests`` (i, s) =
    printfn "%i %s" i s
    Assert.Equal(s, "hello1")

You can drop the `~~` operator if you use `degreesToRadiansCases: Object [] []`, as shown in Tyson's answer. — DharmaTurtle, Jan 31 '20 at 23:39

In F# how do you pass a collection to xUnit's InlineData attribute

6 Answers6

Linked