F# FsCheck惰性生成器

我在测试中生成数据时遇到问题

    testProperty "calculate Operation against different operations should increase major" <| fun  operationIdApi operationIdClient summaryApi summaryClient descriptionApi descriptionClient   -> 
    ( notAllEqual [
            fun () -> assessEquality <| StringEquals(operationIdApi, operationIdClient)
            fun () -> assessEquality <| StringEquals(summaryApi , summaryClient)
            fun () -> assessEquality <| StringEquals(descriptionApi, descriptionClient)
        ]) ==> lazy (
        let operationClient = createOpenApiOperation operationIdClient summaryClient descriptionClient
        let operationAPI = createOpenApiOperation operationIdApi summaryApi descriptionApi
        let actual = calculate operationAPI operationClient
        Expect.equal actual (Fact.Semver.IncreaseMajor) "return IncreaseMajor"
    )

Get方法还不存在，所以我准备通过向ElementSet添加一个成员来实现它= |和“a”一样 |不同的 使用此成员。获取= 与此匹配 |相同的s->s

---

|Different->Arb.generate我想我找到了，答案是一开始就处理好了：

let setGen<'a when 'a:equality>   =
    Gen.oneof [
            gen { 
                let! v = Arb.generate<'a>
                return Same(v)
            }
            gen { 
                let! x,y  =
                    Arb.generate<'a>
                    |> Gen.two
                    |> Gen.filter (fun (a,b)-> a <> b)

                return Different(x,y)
            }
    ]

---

我想我找到了，答案是一开始就处理好了：

let setGen<'a when 'a:equality>   =
    Gen.oneof [
            gen { 
                let! v = Arb.generate<'a>
                return Same(v)
            }
            gen { 
                let! x,y  =
                    Arb.generate<'a>
                    |> Gen.two
                    |> Gen.filter (fun (a,b)-> a <> b)

                return Different(x,y)
            }
    ]

type ElementSet<'a> =
    | Same of 'a
    | Different 

let setGen<'a> =
    Gen.oneof [
            gen { 
                let! v = Arb.generate<'a>
                return Same(v)
            }
            gen { return Different}
    ]

type ElementSetGenerator =
    static member ElementSet() = 
        Arb.fromGen setGen<'a>

do Arb.register<ElementSetGenerator>() |> ignore

let createOpenApiOperation operationId summary=
let pi  = OpenApiOperation(OperationId=operationId.Get, Summary=summary.Get)    
pi

type ElementSet<'a> =
    | Same of 'a
    | Different 
    with member this.Get = 
        match this with
            | Same s -> s
            | Different ->  Arb.generate<'a>// some random generation here 

let setGen<'a when 'a:equality>   =
    Gen.oneof [
            gen { 
                let! v = Arb.generate<'a>
                return Same(v)
            }
            gen { 
                let! x,y  =
                    Arb.generate<'a>
                    |> Gen.two
                    |> Gen.filter (fun (a,b)-> a <> b)

                return Different(x,y)
            }
    ]

type ElementSet<'a> when 'a:equality=
    | Same of 'a
    | Different of 'a*'a
    with member this.Fst =  match this with | Same s -> s | Different (a, b)->  a
         member this.Snd =  match this with | Same s -> s | Different (a, b)->  b

 testProperty "calculate Operation against different operations should increase major" <| fun  (operationId:ElementSet<NonWhiteSpaceString>)  (summary:ElementSet<NonWhiteSpaceString>) (description:ElementSet<NonWhiteSpaceString>)   -> 
  let operationClient = createOpenApiOperation operationId.Fst summary.Fst description.Fst
  let operationAPI = createOpenApiOperation operationId.Snd summary.Snd description.Snd
  let actual = calculate operationAPI operationClient
  Expect.equal actual (Fact.Semver.IncreaseMajor) "return IncreaseMajor"

let createOpenApiOperation (operationId:NonWhiteSpaceString) (summary:NonWhiteSpaceString) (description:NonWhiteSpaceString)=
let pi  = OpenApiOperation(OperationId=operationId.Get, Summary=summary.Get, Description=description.Get)    
pi