anchor.diff:              let formatted = tryFormatSourceString false sourceCode formatConfig
               tryFormatSourceString false formatted formatConfig = formatted)
   
  +[<Test>]
  +let ``should be able to convert inputs to SynExpr``() =    
  +    "x" |> Input |> toSynExpr |> fun opt -> opt.IsSome |> should equal true
  +    """let rec W = M
  +and b = V
  +and K = a
  +for jf = d downto p do
  +    u""" |> Input |> toSynExpr |> fun opt -> opt.IsSome |> should equal true
  +
  +[<Test>]
  +let ``should be able to shrink inputs``() =    
  +    "fun x -> x" |> Input |> shrinkInput |> Seq.map (fun (Input x) -> x.TrimEnd('\r', '\n')) |> Seq.toArray |> should equal [|"x"|]
  +    """let rec W = M
  +    u""" |> Input |> shrinkInput |> Seq.map (fun (Input x) -> x.TrimEnd('\r', '\n')) |> Seq.toArray |> should equal [|"M"; "u"|]
  +
   
   
            
  
positive.code:             Gen.map (fun x -> SynConst.String(x, zero)) Arb.generate<_>
              Gen.map (fun x -> SynConst.Bytes(x, zero)) Arb.generate<_>
              Gen.map SynConst.UInt16s Arb.generate<_>
              (if size <= 2 then Gen.constant SynConst.Unit 
               else
                  let genSubSynConst = generateSynConst (size/2)
                  Gen.map2 (fun x y -> SynConst.Measure(x, y)) genSubSynConst generateSynMeasure) 
          ]
  
  let alphaFreqList =
  
negative.code:     let genSubIdent = generateIdent (size/2)
      Gen.map (fun s -> SynExpr.Ident(Ident(s, zero))) genSubIdent
  
  /// Complex expressions are only nested for function definitions and some control-flow constructs.
  and generateSynExpr size =
      if size <= 2 then
          generateIdentExpr size
      else
          let genSubSynExpr = generateSynExpr (size/2)
          let genSubBasicExpr = generateBasicExpr (size/2)
          let genSubBasicExprList = Gen.listOf genSubBasicExpr
          let genSubIdentExpr = generateIdentExpr (size/2)
          let genSubSynType = generateSynType (size/2)
          let genSubSynTypeList = Gen.listOf genSubSynType
  