FSCheck for Newtonsoft.Json

GenJObject.fs

let genByteArray = Gen.arrayOf Arb.generate<byte>

let genJValue =
    Gen.oneof
        [
            Arb.generate<int> |> Gen.map JValue
            Arb.generate<UInt32> |> Gen.map JValue
            Arb.generate<bool> |> Gen.map JValue
            Arb.generate<char> |> Gen.map JValue
            Arb.generate<DateTime> |> Gen.map JValue
            Arb.generate<DateTimeOffset> |> Gen.map JValue
            Arb.generate<Decimal> |> Gen.map JValue
            Arb.generate<double> |> Gen.map JValue
            Arb.generate<Guid> |> Gen.map JValue
            Arb.generate<int64> |> Gen.map JValue
            Arb.generate<single> |> Gen.map JValue
            Arb.generate<string> |> Gen.map JValue
            Arb.generate<TimeSpan> |> Gen.map JValue
            Arb.generate<UInt64> |> Gen.map JValue
            //Arb.generate<Uri> |> Gen.map JValue
            genByteArray |> Gen.map JValue
        ]

let mapGenToToken<'t when 't :> JToken> = Gen.map (fun (x: 't) -> x:> JToken)

let rec genJToken' s =
    match s with
    | 0 -> genJValue |> mapGenToToken
    | n when n > 0 ->
        Gen.oneof
            [
                genJValue |> mapGenToToken
                genJArray' (n/2) |> mapGenToToken
                genJObject' (n/2) |> mapGenToToken
            ]
    | _ -> invalidArg "s" "Only positive arguments are allowed"

and genJArray' s =
    match s with
    | 0 -> Gen.constant (JArray())
    | n when n > 0 ->
        genJToken' n
        |> Gen.arrayOf
        |> Gen.map JArray
    | _ -> invalidArg "s" "Only positive arguments are allowed"

and genJObject' s =
    match s with
    | 0 -> Gen.constant (JObject())
    | n when n > 0 ->
        gen {
            let! key = Arb.generate<string>
            let! value = genJToken' n
            return key, value
        }
        |> Gen.arrayOf
        |> Gen.map(fun arr ->
            let result = JObject()
            for (key, value) in arr do
                result.Add(key, value)
            result)
    | _ -> invalidArg "s" "Only positive arguments are allowed"

let genJToken = Gen.sized genJToken'
let genJArray = Gen.sized genJArray'
let genJObject = Gen.sized genJObject'

type ProtocolGenerators =
    static member JToken() = Arb.fromGen genJToken
    static member JArray() = Arb.fromGen genJArray
    static member JObject() = Arb.fromGen genJObject

let config = { FsCheck.Config.Default with Arbitrary = [typeof<ProtocolGenerators>] }