FsCheck code snippets

fscheck_generator.fs

let rec generateDeclExpr size =
    if size <= 2 then
        generateIdentExpr size
    else
        let genSubDeclExpr = generateDeclExpr (size/2)
        let genSubDeclExprList = Gen.listOf genSubDeclExpr
        let genSubIdentExpr = generateIdentExpr (size/2)
        let genSubSynType = generateSynType (size/2)
        let genSubSynTypeList = Gen.listOf genSubSynType
        let genSubSynPat = generateSynPat (size/2)
        let genSubIdent = generateIdent (size/2)
        let genSubLongIdentWithDots = generateLongIdentWithDots (size/2)
        let genSubSynConst = generateSynConst (size/2)
        let generateSynBindingList = Gen.listOf (generateSynBinding (size/2))
        let genSubSynMatchClauseList = Gen.listOf (generateSynMatchClause (size/2))
        let genSubSynSimplePats = generateSynSimplePats (size/2)
        Gen.frequency 
            [ 
                8, Gen.map3 (fun b bindings expr -> SynExpr.LetOrUse(b, false, bindings, expr, zero)) Arb.generate<_> generateSynBindingList genSubDeclExpr //
                4, Gen.map2 (fun expr clauses -> SynExpr.Match(NoSequencePointAtDoBinding, expr, clauses, false, zero)) genSubDeclExpr genSubSynMatchClauseList //                
                4, Gen.map2 (fun b clauses -> SynExpr.MatchLambda(b, zero, clauses, NoSequencePointAtDoBinding, zero)) Arb.generate<_> genSubSynMatchClauseList //
                4, Gen.map3 (fun b pat expr -> SynExpr.Lambda(b, false, pat, expr, zero)) Arb.generate<_> genSubSynSimplePats genSubDeclExpr //
                1, Gen.map2 (fun expr1 expr2 -> SynExpr.TryFinally(expr1, expr2, zero, NoSequencePointAtTry, NoSequencePointAtFinally)) genSubDeclExpr genSubDeclExpr //
                1, Gen.map2 (fun expr clauses -> SynExpr.TryWith(expr, zero, clauses, zero, zero, NoSequencePointAtTry, NoSequencePointAtWith)) genSubDeclExpr genSubSynMatchClauseList //
                1, Gen.map (fun c -> SynExpr.Const(c, zero)) genSubSynConst //
                1, Gen.map2 (fun expr typ -> SynExpr.Typed(expr, typ, zero)) genSubDeclExpr genSubSynType
                2, Gen.map (fun exprs -> SynExpr.Tuple(exprs, exprs |> List.map (fun _ -> zero), zero)) genSubDeclExprList //
                2, Gen.map2 (fun b exprs -> SynExpr.ArrayOrList(b, exprs, zero)) Arb.generate<_> genSubDeclExprList
                1, Gen.map3 (fun b typ expr -> SynExpr.New(b, typ, SynExpr.Paren(expr, zero, None, zero), zero)) Arb.generate<_> genSubSynType genSubDeclExpr
                1, Gen.map2 (fun expr1 expr2 -> SynExpr.While(NoSequencePointAtWhileLoop, expr1, expr2, zero)) genSubDeclExpr genSubDeclExpr //
                1, Gen.map2 (fun b expr -> SynExpr.ArrayOrListOfSeqExpr(b, expr, zero)) Arb.generate<_> genSubDeclExpr
                1, Gen.map2 (fun b expr -> SynExpr.CompExpr(b, ref true, expr, zero)) Arb.generate<_> genSubDeclExpr
                1, Gen.map (fun expr -> SynExpr.Do(expr, zero)) genSubDeclExpr //
                1, Gen.map (fun expr -> SynExpr.Assert(expr, zero)) genSubDeclExpr //
                1, Gen.map (fun expr -> SynExpr.Paren(expr, zero, None, zero)) genSubDeclExpr
                1, genSubIdentExpr
                1, Gen.map2 (fun b expr -> SynExpr.AddressOf(b, expr, zero, zero)) Arb.generate<_> genSubIdentExpr
                1, Gen.constant (SynExpr.Null zero)
                1, Gen.map (fun expr -> SynExpr.InferredDowncast(expr, zero)) genSubIdentExpr
                1, Gen.map (fun expr -> SynExpr.InferredUpcast(expr, zero)) genSubIdentExpr
                1, Gen.map2 (fun expr typ -> SynExpr.Upcast(expr, typ, zero)) genSubIdentExpr genSubSynType //
                1, Gen.map2 (fun expr typ -> SynExpr.Downcast(expr, typ, zero)) genSubIdentExpr genSubSynType //
                1, Gen.map2 (fun expr typ -> SynExpr.TypeTest(expr, typ, zero)) genSubIdentExpr genSubSynType //
                1, Gen.map2 (fun expr1 expr2 -> SynExpr.DotIndexedGet(expr1, [SynIndexerArg.One expr2], zero, zero)) genSubDeclExpr genSubDeclExpr
                1, Gen.map3 (fun expr1 expr2 expr3 -> SynExpr.DotIndexedSet(expr1, [SynIndexerArg.One expr3], expr2, zero, zero, zero)) genSubDeclExpr genSubDeclExpr genSubDeclExpr
                1, Gen.map2 (fun expr longIdent -> SynExpr.DotGet(expr, zero, longIdent, zero)) genSubDeclExpr genSubLongIdentWithDots
                1, Gen.map3 (fun expr1 expr2 longIdent -> SynExpr.DotSet(expr1, longIdent, expr2, zero)) genSubDeclExpr genSubDeclExpr genSubLongIdentWithDots
                1, Gen.map2 (fun expr longIdent -> SynExpr.LongIdentSet(longIdent, expr, zero)) genSubDeclExpr genSubLongIdentWithDots
                1, Gen.map2 (fun b longIdent -> SynExpr.LongIdent(b, longIdent, None, zero)) Arb.generate<_> genSubLongIdentWithDots
                2, Gen.map2 (fun expr1 expr2 -> SynExpr.Sequential(SequencePointsAtSeq, true, expr1, expr2, zero)) genSubDeclExpr genSubDeclExpr
                1, Gen.map (fun expr -> SynExpr.Lazy(expr, zero)) genSubDeclExpr //
                1, Gen.map2 (fun expr typs -> SynExpr.TypeApp(expr, zero, typs, typs |> List.map (fun _ -> zero), None, zero, zero)) genSubDeclExpr genSubSynTypeList
                4, Gen.map3 (fun b expr1 expr2 -> SynExpr.App(ExprAtomicFlag.NonAtomic, b, expr1, expr2, zero)) Arb.generate<_> genSubDeclExpr genSubDeclExpr
                2, Gen.map5 (fun b expr1 expr2 expr3 s -> SynExpr.For(NoSequencePointAtForLoop, Ident(s, zero), expr1, b, expr2, expr3, zero)) Arb.generate<_> genSubDeclExpr genSubDeclExpr genSubDeclExpr genSubIdent //
                2, Gen.map5 (fun b1 b2 expr1 expr2 pat -> SynExpr.ForEach(NoSequencePointAtForLoop, SeqExprOnly b1, b2, pat, expr1, expr2, zero)) Arb.generate<_> Arb.generate<_> genSubDeclExpr genSubDeclExpr genSubSynPat //
            ]

fscheck_property.fs

[<Test>]
let ``running formatting twice should produce the same results``() =    
    Check.One(verboseConf,
        fun (Input sourceCode) ->
            let formatted = tryFormatSourceString false sourceCode formatConfig
            tryFormatSourceString false formatted formatConfig = formatted)