, true) with
- | null | [| |] -> None
- | res ->
- let attr = (res.[0] :?> StructuredFormatDisplayAttribute)
- let txt = attr.Value
- if isNull txt || txt.Length <= 1 then
- None
- else
- let messageRegexPattern = @"^(?.*?)(?.*?)(?.*)$"
- let illFormedBracketPattern = @"(?
- // there isn't a match on the regex looking for a property, so now let's make sure we don't have an ill-formed format string (i.e. mismatched/stray brackets)
- let illFormedMatch = System.Text.RegularExpressions.Regex.IsMatch(txt, illFormedBracketPattern)
- match illFormedMatch with
- | true -> None // there are mismatched brackets, bail out
- | false when layouts.Length > 1 -> Some (spaceListL (List.rev ((wordL (tagText(replaceEscapedBrackets(txt))) :: layouts))))
- | false -> Some (wordL (tagText(replaceEscapedBrackets(txt))))
- | true ->
- // we have a hit on a property reference
- let preText = replaceEscapedBrackets(m.Groups.["pre"].Value) // everything before the first opening bracket
- let postText = m.Groups.["post"].Value // Everything after the closing bracket
- let prop = replaceEscapedBrackets(m.Groups.["prop"].Value) // Unescape everything between the opening and closing brackets
-
- match catchExn (fun () -> getProperty ty x prop) with
- | Choice2Of2 e -> Some (wordL (tagText("")))
- | Choice1Of2 alternativeObj ->
- try
- let alternativeObjL =
- match alternativeObj with
- // A particular rule is that if the alternative property
- // returns a string, we turn off auto-quoting and escaping of
- // the string, i.e. just treat the string as display text.
- // This allows simple implementations of
- // such as
- //
- // []
- // type BigInt(signInt:int, v : BigNat) =
- // member x.StructuredDisplayString = x.ToString()
- //
- | :? string as s -> sepL (tagText s)
- | _ ->
- // recursing like this can be expensive, so let's throttle it severely
- sameObjL (depthLim/10) Precedence.BracketIfTuple (alternativeObj, alternativeObj.GetType())
- countNodes 0 // 0 means we do not count the preText and postText
-
- let postTextMatch = System.Text.RegularExpressions.Regex.Match(postText, messageRegexPattern)
- // the postText for this node will be everything up to the next occurrence of an opening brace, if one exists
- let currentPostText =
- match postTextMatch.Success with
- | false -> postText
- | true -> postTextMatch.Groups.["pre"].Value
-
- let newLayouts = (sepL (tagText preText) ^^ alternativeObjL ^^ sepL (tagText currentPostText)) :: layouts
- match postText with
- | "" ->
- //We are done, build a space-delimited layout from the collection of layouts we've accumulated
- Some (spaceListL (List.rev newLayouts))
- | remainingPropertyText when postTextMatch.Success ->
-
- // look for stray brackets in the text before the next opening bracket
- let strayClosingMatch = System.Text.RegularExpressions.Regex.IsMatch(postTextMatch.Groups.["pre"].Value, illFormedBracketPattern)
- match strayClosingMatch with
- | true -> None
- | false ->
- // More to process, keep going, using the postText starting at the next instance of a '{'
- let openingBracketIndex = postTextMatch.Groups.["prop"].Index-1
- buildObjMessageL remainingPropertyText.[openingBracketIndex..] newLayouts
- | remaingPropertyText ->
- // make sure we don't have any stray brackets
- let strayClosingMatch = System.Text.RegularExpressions.Regex.IsMatch(remaingPropertyText, illFormedBracketPattern)
- match strayClosingMatch with
- | true -> None
- | false ->
- // We are done, there's more text but it doesn't contain any more properties, we need to remove escaped brackets now though
- // since that wasn't done when creating currentPostText
- Some (spaceListL (List.rev ((sepL (tagText preText) ^^ alternativeObjL ^^ sepL (tagText(replaceEscapedBrackets(remaingPropertyText)))) :: layouts)))
- with _ ->
- None
- // Seed with an empty layout with a space to the left for formatting purposes
- buildObjMessageL txt [leftL (tagText "")]
-#if COMPILER // This is the PrintIntercepts extensibility point currently revealed by fsi.exe's AddPrinter
+ // Lazy values. VS2008 used StructuredFormatDisplayAttribute to show via ToString. Dev10 (no attr) needs a special case.
+ let ty = x.GetType()
+ if ty.IsGenericType && ty.GetGenericTypeDefinition() = typedefof> then
+ Some (wordL (tagText(x.ToString())))
+ else
+ // Try the StructuredFormatDisplayAttribute extensibility attribute
+ match ty.GetCustomAttributes (typeof, true) with
+ | null | [| |] -> None
+ | res ->
+ structuredFormatObjectL showMode ty depthLim (res.[0] :?> StructuredFormatDisplayAttribute) x
+
+#if COMPILER
+ // This is the PrintIntercepts extensibility point currently revealed by fsi.exe's AddPrinter
let res =
match res with
| Some _ -> res
| None ->
- let env = { new IEnvironment with
- member env.GetLayout(y) = objL (depthLim-1) Precedence.BracketIfTuple (y, y.GetType())
- member env.MaxColumns = opts.PrintLength
- member env.MaxRows = opts.PrintLength }
+ let env =
+ { new IEnvironment with
+ member _.GetLayout(y) = nestedObjL (depthLim-1) Precedence.BracketIfTuple (y, y.GetType())
+ member _.MaxColumns = opts.PrintLength
+ member _.MaxRows = opts.PrintLength }
opts.PrintIntercepts |> List.tryPick (fun intercept -> intercept env x)
#endif
let res =
match res with
| Some res -> res
- | None -> reprL showMode (depthLim-1) prec info x
- path .Remove(x) |> ignore;
+ | None -> reprL showMode (depthLim-1) prec info x
+
+ path.Remove(x) |> ignore
res
- with
- e ->
- countNodes 1
- wordL (tagText("Error: " + e.Message))
-
- and recdAtomicTupleL depthLim recd =
- // tuples up args to UnionConstruction or ExceptionConstructor. no node count.
- match recd with
- | [(_,x)] -> objL depthLim Precedence.BracketIfTupleOrNotAtomic x
- | txs -> leftL Literals.leftParen ^^ commaListL (List.map (snd >> objL depthLim Precedence.BracketIfTuple) txs) ^^ rightL Literals.rightParen
-
- and bracketIfL b basicL =
- if b then (leftL Literals.leftParen) ^^ basicL ^^ (rightL Literals.rightParen) else basicL
-
- and reprL showMode depthLim prec repr x (* x could be null *) =
- let showModeFilter lay = match showMode with ShowAll -> lay | ShowTopLevelBinding -> emptyL
- match repr with
- | TupleValue (tupleType, vals) ->
- let basicL = sepListL (rightL Literals.comma) (List.map (objL depthLim Precedence.BracketIfTuple ) vals)
- let fields = bracketIfL (prec <= Precedence.BracketIfTuple) basicL
- match tupleType with
- | TupleType.Value -> structL ^^ fields
- | TupleType.Reference -> fields
-
- | RecordValue items ->
- let itemL (name,x,ty) =
- countNodes 1 // record labels are counted as nodes. [REVIEW: discussion under 4090].
- (tagRecordField name,objL depthLim Precedence.BracketIfTuple (x, ty))
- makeRecordL (List.map itemL items)
-
- | ConstructorValue (_,constr,recd) when // x is List. Note: "null" is never a valid list value.
- x<>null && isListType (x.GetType()) ->
- match constr with
- | "Cons" ->
- let (x,xs) = unpackCons recd
- let project xs = getListValueInfo bindingFlags xs
- let itemLs = objL depthLim Precedence.BracketIfTuple x :: boundedUnfoldL (objL depthLim Precedence.BracketIfTuple) project stopShort xs (opts.PrintLength - 1)
- makeListL itemLs
- | _ ->
- countNodes 1
- wordL (tagPunctuation "[]")
-
- | ConstructorValue(declaringType,nm,recd) ->
- countNodes 1
- let caseName =
- match declaringType with
- | None ->
- wordL (tagMethod nm)
- | Some declaringType ->
- wordL (tagClass declaringType.Name) ^^ sepL (tagPunctuation ".") ^^ wordL (tagMethod nm)
- match recd with
- | [] -> caseName
- | recd -> (caseName --- recdAtomicTupleL depthLim recd) |> bracketIfL (prec <= Precedence.BracketIfTupleOrNotAtomic)
-
- | ExceptionValue(ty,recd) ->
- countNodes 1
- let name = ty.Name
- match recd with
- | [] -> (wordL (tagClass name))
- | recd -> (wordL (tagClass name) --- recdAtomicTupleL depthLim recd) |> bracketIfL (prec <= Precedence.BracketIfTupleOrNotAtomic)
+ with
+ e ->
+ countNodes 1
+ wordL (tagText("Error: " + e.Message))
+
+ // Format an object that has a layout specified by StructuredFormatAttribute
+ and structuredFormatObjectL showMode ty depthLim (attr: StructuredFormatDisplayAttribute) (obj: obj) =
+ let txt = attr.Value
+ if isNull txt || txt.Length <= 1 then
+ None
+ else
+ let messageRegexPattern = @"^(?.*?)(?.*?)(?.*)$"
+ let illFormedBracketPattern = @"(?
- // Q: should function printing include the ty.Name? It does not convey much useful info to most users, e.g. "clo@0_123".
- countNodes 1
- wordL (tagText("")) |> showModeFilter
-
- | ObjectValue(obj) ->
- match obj with
- | null ->
- countNodes 1
- // If this is the root element, wrap the null with angle brackets
- if depthLim = opts.PrintDepth - 1 then
- wordL (tagText "")
- else nullL
- | _ ->
- let ty = obj.GetType()
- match obj with
- | :? string as s ->
- countNodes 1
+ let rec buildObjMessageL (txt:string) (layouts:Layout list) =
+
+ let replaceEscapedBrackets (txt:string) =
+ txt.Replace("\{", "{").Replace("\}", "}")
+
+ // to simplify support for escaped brackets, switch to using a Regex to simply parse the text as the following regex groups:
+ // 1) Everything up to the first opening bracket not preceded by a "\", lazily
+ // 2) Everything between that opening bracket and a closing bracket not preceded by a "\", lazily
+ // 3) Everything after that closing bracket
+ let m = System.Text.RegularExpressions.Regex.Match(txt, messageRegexPattern)
+ if not m.Success then
+ // there isn't a match on the regex looking for a property, so now let's make sure we don't have an ill-formed format string (i.e. mismatched/stray brackets)
+ let illFormedMatch = System.Text.RegularExpressions.Regex.IsMatch(txt, illFormedBracketPattern)
+ if illFormedMatch then
+ None // there are mismatched brackets, bail out
+ elif layouts.Length > 1 then Some (spaceListL (List.rev ((wordL (tagText(replaceEscapedBrackets(txt))) :: layouts))))
+ else Some (wordL (tagText(replaceEscapedBrackets(txt))))
+ else
+ // we have a hit on a property reference
+ let preText = replaceEscapedBrackets(m.Groups.["pre"].Value) // everything before the first opening bracket
+ let postText = m.Groups.["post"].Value // Everything after the closing bracket
+ let prop = replaceEscapedBrackets(m.Groups.["prop"].Value) // Unescape everything between the opening and closing brackets
+
+ match catchExn (fun () -> getProperty ty obj prop) with
+ | Choice2Of2 e -> Some (wordL (tagText("")))
+ | Choice1Of2 alternativeObj ->
+ try
+ let alternativeObjL =
+ match alternativeObj with
+ // A particular rule is that if the alternative property
+ // returns a string, we turn off auto-quoting and escaping of
+ // the string, i.e. just treat the string as display text.
+ // This allows simple implementations of
+ // such as
+ //
+ // []
+ // type BigInt(signInt:int, v: BigNat) =
+ // member x.StructuredDisplayString = x.ToString()
+ //
+ | :? string as s -> sepL (tagText s)
+ | _ ->
+ // recursing like this can be expensive, so let's throttle it severely
+ objL showMode (depthLim/10) Precedence.BracketIfTuple (alternativeObj, alternativeObj.GetType())
+ countNodes 0 // 0 means we do not count the preText and postText
+
+ let postTextMatch = System.Text.RegularExpressions.Regex.Match(postText, messageRegexPattern)
+ // the postText for this node will be everything up to the next occurrence of an opening brace, if one exists
+ let currentPostText =
+ match postTextMatch.Success with
+ | false -> postText
+ | true -> postTextMatch.Groups.["pre"].Value
+
+ let newLayouts = (sepL (tagText preText) ^^ alternativeObjL ^^ sepL (tagText currentPostText)) :: layouts
+ match postText with
+ | "" ->
+ //We are done, build a space-delimited layout from the collection of layouts we've accumulated
+ Some (spaceListL (List.rev newLayouts))
+
+ | remainingPropertyText when postTextMatch.Success ->
+
+ // look for stray brackets in the text before the next opening bracket
+ let strayClosingMatch = System.Text.RegularExpressions.Regex.IsMatch(postTextMatch.Groups.["pre"].Value, illFormedBracketPattern)
+ if strayClosingMatch then
+ None
+ else
+ // More to process, keep going, using the postText starting at the next instance of a '{'
+ let openingBracketIndex = postTextMatch.Groups.["prop"].Index-1
+ buildObjMessageL remainingPropertyText.[openingBracketIndex..] newLayouts
+
+ | remaingPropertyText ->
+ // make sure we don't have any stray brackets
+ let strayClosingMatch = System.Text.RegularExpressions.Regex.IsMatch(remaingPropertyText, illFormedBracketPattern)
+ if strayClosingMatch then
+ None
+ else
+ // We are done, there's more text but it doesn't contain any more properties, we need to remove escaped brackets now though
+ // since that wasn't done when creating currentPostText
+ Some (spaceListL (List.rev ((sepL (tagText preText) ^^ alternativeObjL ^^ sepL (tagText(replaceEscapedBrackets(remaingPropertyText)))) :: layouts)))
+ with _ ->
+ None
+
+ // Seed with an empty layout with a space to the left for formatting purposes
+ buildObjMessageL txt [leftL (tagText "")]
+
+ and recdAtomicTupleL depthLim recd =
+ // tuples up args to UnionConstruction or ExceptionConstructor. no node count.
+ match recd with
+ | [(_,x)] -> nestedObjL depthLim Precedence.BracketIfTupleOrNotAtomic x
+ | txs -> leftL Literals.leftParen ^^ commaListL (List.map (snd >> nestedObjL depthLim Precedence.BracketIfTuple) txs) ^^ rightL Literals.rightParen
+
+ and bracketIfL flag basicL =
+ if flag then (leftL Literals.leftParen) ^^ basicL ^^ (rightL Literals.rightParen) else basicL
+
+ and tupleValueL depthLim prec vals tupleType =
+ let basicL = sepListL (rightL Literals.comma) (List.map (nestedObjL depthLim Precedence.BracketIfTuple ) (Array.toList vals))
+ let fields = bracketIfL (prec <= Precedence.BracketIfTuple) basicL
+ match tupleType with
+ | TupleType.Value -> structL ^^ fields
+ | TupleType.Reference -> fields
+
+ and recordValueL depthLim items =
+ let itemL (name, x, ty) =
+ countNodes 1
+ tagRecordField name,nestedObjL depthLim Precedence.BracketIfTuple (x, ty)
+ makeRecordL (List.map itemL items)
+
+ and listValueL depthLim constr recd =
+ match constr with
+ | "Cons" ->
+ let (x,xs) = unpackCons recd
+ let project xs = getListValueInfo bindingFlags xs
+ let itemLs = nestedObjL depthLim Precedence.BracketIfTuple x :: boundedUnfoldL (nestedObjL depthLim Precedence.BracketIfTuple) project stopShort xs (opts.PrintLength - 1)
+ makeListL itemLs
+ | _ ->
+ countNodes 1
+ wordL (tagPunctuation "[]")
+
+ and unionCaseValueL depthLim prec (declaringType: Type option) unionCaseName recd =
+ countNodes 1
+ let caseName =
+ match declaringType with
+ | None ->
+ wordL (tagMethod unionCaseName)
+ | Some declaringType ->
+ wordL (tagClass declaringType.Name) ^^ sepL (tagPunctuation ".") ^^ wordL (tagMethod unionCaseName)
+ match recd with
+ | [] -> caseName
+ | recd -> (caseName --- recdAtomicTupleL depthLim recd) |> bracketIfL (prec <= Precedence.BracketIfTupleOrNotAtomic)
+
+ and fsharpExceptionL depthLim prec (exceptionType: Type) recd =
+ countNodes 1
+ let name = exceptionType.Name
+ match recd with
+ | [] -> (wordL (tagClass name))
+ | recd -> (wordL (tagClass name) --- recdAtomicTupleL depthLim recd) |> bracketIfL (prec <= Precedence.BracketIfTupleOrNotAtomic)
+
+ and showModeFilter showMode layout =
+ match showMode with
+ | ShowAll -> layout
+ | ShowTopLevelBinding -> emptyL
+
+ and functionClosureL showMode (closureType: Type) =
+ // Q: should function printing include the ty.Name? It does not convey much useful info to most users, e.g. "clo@0_123".
+ countNodes 1
+ wordL (tagText("")) |> showModeFilter showMode
+
+ and stringValueL (s: string) =
+ countNodes 1
#if COMPILER
- if s.Length + 2(*quotes*) <= opts.StringLimit then
- // With the quotes, it fits within the limit.
- wordL (tagStringLiteral(formatString s))
- else
- // When a string is considered too long to print, there is a choice: what to print?
- // a) -- follows
- // b) -- follows and gives just the length
- // c) "abcdefg"+[n chars] -- gives a prefix and the remaining chars
- wordL (tagStringLiteral(formatStringInWidth opts.StringLimit s))
+ if s.Length + 2(*quotes*) <= opts.StringLimit then
+ // With the quotes, it fits within the limit.
+ wordL (tagStringLiteral(formatString s))
+ else
+ // When a string is considered too long to print, there is a choice: what to print?
+ // a) -- follows
+ // b) -- follows and gives just the length
+ // c) "abcdefg"+[n chars] -- gives a prefix and the remaining chars
+ wordL (tagStringLiteral(formatStringInWidth opts.StringLimit s))
#else
- wordL (tagStringLiteral (formatString s))
-#endif
- | :? Array as arr ->
- let ty = arr.GetType().GetElementType()
- match arr.Rank with
- | 1 ->
- let n = arr.Length
- let b1 = arr.GetLowerBound(0)
- let project depthLim = if depthLim=(b1+n) then None else Some ((box (arr.GetValue(depthLim)), ty),depthLim+1)
- let itemLs = boundedUnfoldL (objL depthLim Precedence.BracketIfTuple) project stopShort b1 opts.PrintLength
- makeArrayL (if b1 = 0 then itemLs else wordL (tagText("bound1="+string_of_int b1)) :: itemLs)
- | 2 ->
- let n1 = arr.GetLength(0)
- let n2 = arr.GetLength(1)
- let b1 = arr.GetLowerBound(0)
- let b2 = arr.GetLowerBound(1)
- let project2 x y =
- if x>=(b1+n1) || y>=(b2+n2) then None
- else Some ((box (arr.GetValue(x,y)), ty),y+1)
- let rowL x = boundedUnfoldL (objL depthLim Precedence.BracketIfTuple) (project2 x) stopShort b2 opts.PrintLength |> makeListL
- let project1 x = if x>=(b1+n1) then None else Some (x,x+1)
- let rowsL = boundedUnfoldL rowL project1 stopShort b1 opts.PrintLength
- makeArray2L (if b1=0 && b2 = 0 then rowsL else wordL (tagText("bound1=" + string_of_int b1)) :: wordL(tagText("bound2=" + string_of_int b2)) :: rowsL)
- | n ->
- makeArrayL [wordL (tagText("rank=" + string_of_int n))]
+ wordL (tagStringLiteral (formatString s))
+#endif
+
+ and arrayValueL depthLim (arr: Array) =
+ let ty = arr.GetType().GetElementType()
+ match arr.Rank with
+ | 1 ->
+ let n = arr.Length
+ let b1 = arr.GetLowerBound(0)
+ let project depthLim = if depthLim=(b1+n) then None else Some ((box (arr.GetValue(depthLim)), ty),depthLim+1)
+ let itemLs = boundedUnfoldL (nestedObjL depthLim Precedence.BracketIfTuple) project stopShort b1 opts.PrintLength
+ makeArrayL (if b1 = 0 then itemLs else wordL (tagText("bound1="+string_of_int b1)) :: itemLs)
+ | 2 ->
+ let n1 = arr.GetLength(0)
+ let n2 = arr.GetLength(1)
+ let b1 = arr.GetLowerBound(0)
+ let b2 = arr.GetLowerBound(1)
+ let project2 x y =
+ if x>=(b1+n1) || y>=(b2+n2) then None
+ else Some ((box (arr.GetValue(x,y)), ty),y+1)
+ let rowL x = boundedUnfoldL (nestedObjL depthLim Precedence.BracketIfTuple) (project2 x) stopShort b2 opts.PrintLength |> makeListL
+ let project1 x = if x>=(b1+n1) then None else Some (x,x+1)
+ let rowsL = boundedUnfoldL rowL project1 stopShort b1 opts.PrintLength
+ makeArray2L (if b1=0 && b2 = 0 then rowsL else wordL (tagText("bound1=" + string_of_int b1)) :: wordL(tagText("bound2=" + string_of_int b2)) :: rowsL)
+ | n ->
+ makeArrayL [wordL (tagText("rank=" + string_of_int n))]
- // Format 'set' and 'map' nicely
- | _ when
- (ty.IsGenericType && (ty.GetGenericTypeDefinition() = typedefof>
- || ty.GetGenericTypeDefinition() = typedefof>) ) ->
- let word = if ty.GetGenericTypeDefinition() = typedefof> then "map" else "set"
- let possibleKeyValueL v =
- let tyv = v.GetType()
- if word = "map" &&
- (match v with null -> false | _ -> true) &&
- tyv.IsGenericType &&
- tyv.GetGenericTypeDefinition() = typedefof> then
- objL depthLim Precedence.BracketIfTuple ((tyv.GetProperty("Key").GetValue(v, [| |]),
- tyv.GetProperty("Value").GetValue(v, [| |])), tyv)
- else
- objL depthLim Precedence.BracketIfTuple (v, tyv)
- let it = (obj :?> System.Collections.IEnumerable).GetEnumerator()
- try
- let itemLs = boundedUnfoldL possibleKeyValueL (fun () -> if it.MoveNext() then Some(it.Current,()) else None) stopShort () (1+opts.PrintLength/12)
- (wordL (tagClass word) --- makeListL itemLs) |> bracketIfL (prec <= Precedence.BracketIfTupleOrNotAtomic)
- finally
- match it with
- | :? System.IDisposable as e -> e.Dispose()
- | _ -> ()
-
- | :? System.Collections.IEnumerable as ie ->
- let showContent =
- // do not display content of IQueryable since its execution may take significant time
- opts.ShowIEnumerable && (ie.GetType().GetInterfaces() |> Array.exists(fun ty -> ty.FullName = "System.Linq.IQueryable") |> not)
-
- if showContent then
- let word = "seq"
- let it = ie.GetEnumerator()
- let ty = ie.GetType().GetInterfaces() |> Array.filter (fun ty -> ty.IsGenericType && ty.Name = "IEnumerable`1") |> Array.tryItem 0
- let ty = Option.map (fun (ty:Type) -> ty.GetGenericArguments().[0]) ty
- try
- let itemLs = boundedUnfoldL (objL depthLim Precedence.BracketIfTuple) (fun () -> if it.MoveNext() then Some((it.Current, match ty with | None -> it.Current.GetType() | Some ty -> ty),()) else None) stopShort () (1+opts.PrintLength/30)
- (wordL (tagClass word) --- makeListL itemLs) |> bracketIfL (prec <= Precedence.BracketIfTupleOrNotAtomic)
- finally
- match it with
- | :? System.IDisposable as e -> e.Dispose()
- | _ -> ()
+ and mapSetValueL depthLim prec (ty: Type) (obj: obj) =
+ let word = if ty.GetGenericTypeDefinition() = typedefof> then "map" else "set"
+ let possibleKeyValueL v =
+ let tyv = v.GetType()
+ if word = "map" &&
+ (match v with null -> false | _ -> true) &&
+ tyv.IsGenericType &&
+ tyv.GetGenericTypeDefinition() = typedefof> then
+ nestedObjL depthLim Precedence.BracketIfTuple ((tyv.GetProperty("Key").GetValue(v, [| |]),
+ tyv.GetProperty("Value").GetValue(v, [| |])), tyv)
+ else
+ nestedObjL depthLim Precedence.BracketIfTuple (v, tyv)
+ let it = (obj :?> System.Collections.IEnumerable).GetEnumerator()
+ try
+ let itemLs = boundedUnfoldL possibleKeyValueL (fun () -> if it.MoveNext() then Some(it.Current,()) else None) stopShort () (1+opts.PrintLength/12)
+ (wordL (tagClass word) --- makeListL itemLs) |> bracketIfL (prec <= Precedence.BracketIfTupleOrNotAtomic)
+ finally
+ match it with
+ | :? System.IDisposable as e -> e.Dispose()
+ | _ -> ()
+
+ and sequenceValueL showMode depthLim prec (ie: System.Collections.IEnumerable) =
+ let showContent =
+ // do not display content of IQueryable since its execution may take significant time
+ opts.ShowIEnumerable && (ie.GetType().GetInterfaces() |> Array.exists(fun ty -> ty.FullName = "System.Linq.IQueryable") |> not)
+
+ if showContent then
+ let word = "seq"
+ let it = ie.GetEnumerator()
+ let ty = ie.GetType().GetInterfaces() |> Array.filter (fun ty -> ty.IsGenericType && ty.Name = "IEnumerable`1") |> Array.tryItem 0
+ let ty = Option.map (fun (ty:Type) -> ty.GetGenericArguments().[0]) ty
+ try
+ let itemLs = boundedUnfoldL (nestedObjL depthLim Precedence.BracketIfTuple) (fun () -> if it.MoveNext() then Some((it.Current, match ty with | None -> it.Current.GetType() | Some ty -> ty),()) else None) stopShort () (1+opts.PrintLength/30)
+ (wordL (tagClass word) --- makeListL itemLs) |> bracketIfL (prec <= Precedence.BracketIfTupleOrNotAtomic)
+ finally
+ match it with
+ | :? System.IDisposable as e -> e.Dispose()
+ | _ -> ()
- else
- // Sequence printing is turned off for declared-values, and maybe be disabled to users.
- // There is choice here, what to print? or ... or ?
- // Also, in the declared values case, if the sequence is actually a known non-lazy type (list, array etc etc) we could print it.
- wordL (tagText "") |> showModeFilter
- | _ ->
- if showMode = ShowTopLevelBinding && typeUsesSystemObjectToString ty then
- emptyL
- else
- countNodes 1
- let basicL = LayoutOps.objL obj // This buries an obj in the layout, rendered at squash time via a leafFormatter.
- // If the leafFormatter was directly here, then layout leaves could store strings.
- match obj with
- | _ when opts.ShowProperties ->
- let props = ty.GetProperties(BindingFlags.GetField ||| BindingFlags.Instance ||| BindingFlags.Public)
- let fields = ty.GetFields(BindingFlags.Instance ||| BindingFlags.Public) |> Array.map (fun i -> i :> MemberInfo)
- let propsAndFields =
- props |> Array.map (fun i -> i :> MemberInfo)
- |> Array.append fields
- |> Array.filter (fun pi ->
- // check if property is annotated with System.Diagnostics.DebuggerBrowsable(Never).
- // Its evaluation may have unexpected side effects and\or block printing.
- match Seq.toArray (pi.GetCustomAttributes(typeof, false)) with
- | [|:? System.Diagnostics.DebuggerBrowsableAttribute as attr |] -> attr.State <> System.Diagnostics.DebuggerBrowsableState.Never
- | _ -> true
- )
-
- // massively reign in deep printing of properties
- let nDepth = depthLim/10
+ else
+ // Sequence printing is turned off for declared-values, and maybe be disabled to users.
+ // There is choice here, what to print? or ... or ?
+ // Also, in the declared values case, if the sequence is actually a known non-lazy type (list, array etc etc) we could print it.
+ wordL (tagText "") |> showModeFilter showMode
+
+ and objectValueWithPropertiesL depthLim (ty: Type) (obj: obj) =
+
+ // This buries an obj in the layout, rendered at squash time via a leafFormatter.
+ let basicL = LayoutOps.objL obj
+ let props = ty.GetProperties(BindingFlags.GetField ||| BindingFlags.Instance ||| BindingFlags.Public)
+ let fields = ty.GetFields(BindingFlags.Instance ||| BindingFlags.Public) |> Array.map (fun i -> i :> MemberInfo)
+ let propsAndFields =
+ props |> Array.map (fun i -> i :> MemberInfo)
+ |> Array.append fields
+ |> Array.filter (fun pi ->
+ // check if property is annotated with System.Diagnostics.DebuggerBrowsable(Never).
+ // Its evaluation may have unexpected side effects and\or block printing.
+ match Seq.toArray (pi.GetCustomAttributes(typeof, false)) with
+ | [|:? System.Diagnostics.DebuggerBrowsableAttribute as attr |] -> attr.State <> System.Diagnostics.DebuggerBrowsableState.Never
+ | _ -> true
+ )
+
+ // massively reign in deep printing of properties
+ let nDepth = depthLim/10
#if NETSTANDARD
- Array.Sort((propsAndFields),{ new IComparer with member this.Compare(p1,p2) = compare (p1.Name) (p2.Name) } )
+ Array.Sort((propsAndFields),{ new IComparer with member this.Compare(p1,p2) = compare (p1.Name) (p2.Name) } )
#else
- Array.Sort((propsAndFields :> Array),{ new System.Collections.IComparer with member this.Compare(p1,p2) = compare ((p1 :?> MemberInfo).Name) ((p2 :?> MemberInfo).Name) } )
+ Array.Sort((propsAndFields :> Array),{ new System.Collections.IComparer with member this.Compare(p1,p2) = compare ((p1 :?> MemberInfo).Name) ((p2 :?> MemberInfo).Name) } )
#endif
- if propsAndFields.Length = 0 || (nDepth <= 0) then basicL
- else basicL ---
- (propsAndFields
- |> Array.map
- (fun m ->
- ((if m :? FieldInfo then tagField m.Name else tagProperty m.Name),
- (try Some (objL nDepth Precedence.BracketIfTuple ((getProperty ty obj m.Name), ty))
- with _ -> try Some (objL nDepth Precedence.BracketIfTuple ((getField obj (m :?> FieldInfo)), ty))
- with _ -> None)))
- |> Array.toList
- |> makePropertiesL)
- | _ -> basicL
- | UnitValue -> countNodes 1; measureL
-
- polyL bindingFlags objWithReprL showMode opts.PrintDepth Precedence.BracketIfTuple (x, ty)
-
- // --------------------------------------------------------------------
- // pprinter: leafFormatter
- // --------------------------------------------------------------------
-
- let leafFormatter (opts:FormatOptions) (obj :obj) =
- match obj with
- | null -> tagKeyword "null"
- | :? double as d ->
- let s = d.ToString(opts.FloatingPointFormat,opts.FormatProvider)
- let t =
- if System.Double.IsNaN(d) then "nan"
- elif System.Double.IsNegativeInfinity(d) then "-infinity"
- elif System.Double.IsPositiveInfinity(d) then "infinity"
- elif opts.FloatingPointFormat.[0] = 'g' && String.forall(fun c -> System.Char.IsDigit(c) || c = '-') s
- then s + ".0"
- else s
- tagNumericLiteral t
- | :? single as d ->
- let t =
- (if System.Single.IsNaN(d) then "nan"
- elif System.Single.IsNegativeInfinity(d) then "-infinity"
- elif System.Single.IsPositiveInfinity(d) then "infinity"
- elif opts.FloatingPointFormat.Length >= 1 && opts.FloatingPointFormat.[0] = 'g'
- && float32(System.Int32.MinValue) < d && d < float32(System.Int32.MaxValue)
- && float32(int32(d)) = d
- then (System.Convert.ToInt32 d).ToString(opts.FormatProvider) + ".0"
- else d.ToString(opts.FloatingPointFormat,opts.FormatProvider))
- + "f"
- tagNumericLiteral t
- | :? System.Decimal as d -> d.ToString("g",opts.FormatProvider) + "M" |> tagNumericLiteral
- | :? uint64 as d -> d.ToString(opts.FormatProvider) + "UL" |> tagNumericLiteral
- | :? int64 as d -> d.ToString(opts.FormatProvider) + "L" |> tagNumericLiteral
- | :? int32 as d -> d.ToString(opts.FormatProvider) |> tagNumericLiteral
- | :? uint32 as d -> d.ToString(opts.FormatProvider) + "u" |> tagNumericLiteral
- | :? int16 as d -> d.ToString(opts.FormatProvider) + "s" |> tagNumericLiteral
- | :? uint16 as d -> d.ToString(opts.FormatProvider) + "us" |> tagNumericLiteral
- | :? sbyte as d -> d.ToString(opts.FormatProvider) + "y" |> tagNumericLiteral
- | :? byte as d -> d.ToString(opts.FormatProvider) + "uy" |> tagNumericLiteral
- | :? nativeint as d -> d.ToString() + "n" |> tagNumericLiteral
- | :? unativeint as d -> d.ToString() + "un" |> tagNumericLiteral
- | :? bool as b -> (if b then "true" else "false") |> tagKeyword
- | :? char as c -> "\'" + formatChar true c + "\'" |> tagStringLiteral
- | _ ->
- let t =
- try
- let text = obj.ToString()
- match text with
- | null -> ""
- | _ -> text
- with e ->
- // If a .ToString() call throws an exception, catch it and use the message as the result.
- // This may be informative, e.g. division by zero etc...
- ""
- tagText t
-
- let any_to_layout opts x = anyL ShowAll BindingFlags.Public opts x
-
- let squash_layout opts l =
- // Print width = 0 implies 1D layout, no squash
- if opts.PrintWidth = 0 then
- l
- else
- l |> squashTo (opts.PrintWidth,leafFormatter opts)
-
- let asTaggedTextWriter (tw: TextWriter) =
- { new TaggedTextWriter with
- member __.Write(t) = tw.Write t.Text
- member __.WriteLine() = tw.WriteLine() }
-
- let output_layout_tagged opts oc l =
- l |> squash_layout opts
- |> outL opts.AttributeProcessor (leafFormatter opts) oc
+ if propsAndFields.Length = 0 || (nDepth <= 0) then basicL
+ else basicL ---
+ (propsAndFields
+ |> Array.map
+ (fun m ->
+ ((if m :? FieldInfo then tagField m.Name else tagProperty m.Name),
+ (try Some (nestedObjL nDepth Precedence.BracketIfTuple ((getProperty ty obj m.Name), ty))
+ with _ ->
+ try Some (nestedObjL nDepth Precedence.BracketIfTuple ((getField obj (m :?> FieldInfo)), ty))
+ with _ -> None)))
+ |> Array.toList
+ |> makePropertiesL)
+
+ and reprL showMode depthLim prec repr x (* x could be null *) =
+ match repr with
+ | TupleValue (tupleType, vals) ->
+ tupleValueL depthLim prec vals tupleType
+
+ | RecordValue items ->
+ recordValueL depthLim (Array.toList items)
+
+ | UnionCaseValue (_,constr,recd) when // x is List. Note: "null" is never a valid list value.
+ x<>null && isListType (x.GetType()) ->
+ listValueL depthLim constr recd
+
+ | UnionCaseValue(declaringType, unionCaseName, recd) ->
+ unionCaseValueL depthLim prec declaringType unionCaseName (Array.toList recd)
+
+ | ExceptionValue(exceptionType, recd) ->
+ fsharpExceptionL depthLim prec exceptionType (Array.toList recd)
+
+ | FunctionClosureValue closureType ->
+ functionClosureL showMode closureType
+
+ | UnitValue ->
+ countNodes 1
+ unitL
+
+ | NullValue ->
+ countNodes 1
+ // If this is the root element, wrap the null with angle brackets
+ if depthLim = opts.PrintDepth - 1 then
+ wordL (tagText "")
+ else nullL
+
+ | ObjectValue obj ->
+ let ty = obj.GetType()
+ match obj with
+ | :? string as s ->
+ stringValueL s
- let output_layout opts oc l =
- output_layout_tagged opts (asTaggedTextWriter oc) l
+ | :? Array as arr ->
+ arrayValueL depthLim arr
- let layout_to_string options layout =
- layout |> squash_layout options
- |> showL options ((leafFormatter options) >> toText)
+ | _ when isSetOrMapType ty ->
+ mapSetValueL depthLim prec ty obj
- let output_any_ex opts oc x = x |> any_to_layout opts |> output_layout opts oc
+ | :? System.Collections.IEnumerable as ie ->
+ sequenceValueL showMode depthLim prec ie
- let output_any writer x = output_any_ex FormatOptions.Default writer x
+ | _ when showMode = ShowTopLevelBinding && typeUsesSystemObjectToString ty ->
+ emptyL
- let layout_as_string opts x = x |> any_to_layout opts |> layout_to_string opts
+ | _ when opts.ShowProperties ->
+ countNodes 1
+ objectValueWithPropertiesL depthLim (ty: Type) (obj: obj)
- let any_to_string x = layout_as_string FormatOptions.Default x
+ | _ ->
+ countNodes 1
+ // This buries an obj in the layout, rendered at squash time via a leafFormatter.
+ LayoutOps.objL obj
+
+ member _.Format(showMode, x:'a, xty:Type) =
+ objL showMode opts.PrintDepth Precedence.BracketIfTuple (x, xty)
+
+ let leafFormatter (opts:FormatOptions) (obj :obj) =
+ match obj with
+ | null -> tagKeyword "null"
+ | :? double as d ->
+ let s = d.ToString(opts.FloatingPointFormat,opts.FormatProvider)
+ let t =
+ if System.Double.IsNaN(d) then "nan"
+ elif System.Double.IsNegativeInfinity(d) then "-infinity"
+ elif System.Double.IsPositiveInfinity(d) then "infinity"
+ elif opts.FloatingPointFormat.[0] = 'g' && String.forall(fun c -> System.Char.IsDigit(c) || c = '-') s
+ then s + ".0"
+ else s
+ tagNumericLiteral t
+
+ | :? single as d ->
+ let t =
+ (if System.Single.IsNaN(d) then "nan"
+ elif System.Single.IsNegativeInfinity(d) then "-infinity"
+ elif System.Single.IsPositiveInfinity(d) then "infinity"
+ elif opts.FloatingPointFormat.Length >= 1 && opts.FloatingPointFormat.[0] = 'g'
+ && float32(System.Int32.MinValue) < d && d < float32(System.Int32.MaxValue)
+ && float32(int32(d)) = d
+ then (System.Convert.ToInt32 d).ToString(opts.FormatProvider) + ".0"
+ else d.ToString(opts.FloatingPointFormat,opts.FormatProvider))
+ + "f"
+ tagNumericLiteral t
+
+ | :? decimal as d -> d.ToString("g",opts.FormatProvider) + "M" |> tagNumericLiteral
+ | :? uint64 as d -> d.ToString(opts.FormatProvider) + "UL" |> tagNumericLiteral
+ | :? int64 as d -> d.ToString(opts.FormatProvider) + "L" |> tagNumericLiteral
+ | :? int32 as d -> d.ToString(opts.FormatProvider) |> tagNumericLiteral
+ | :? uint32 as d -> d.ToString(opts.FormatProvider) + "u" |> tagNumericLiteral
+ | :? int16 as d -> d.ToString(opts.FormatProvider) + "s" |> tagNumericLiteral
+ | :? uint16 as d -> d.ToString(opts.FormatProvider) + "us" |> tagNumericLiteral
+ | :? sbyte as d -> d.ToString(opts.FormatProvider) + "y" |> tagNumericLiteral
+ | :? byte as d -> d.ToString(opts.FormatProvider) + "uy" |> tagNumericLiteral
+ | :? nativeint as d -> d.ToString() + "n" |> tagNumericLiteral
+ | :? unativeint as d -> d.ToString() + "un" |> tagNumericLiteral
+ | :? bool as b -> (if b then "true" else "false") |> tagKeyword
+ | :? char as c -> "\'" + formatChar true c + "\'" |> tagStringLiteral
+
+ | _ ->
+ let t =
+ try
+ let text = obj.ToString()
+ match text with
+ | null -> ""
+ | _ -> text
+ with e ->
+ // If a .ToString() call throws an exception, catch it and use the message as the result.
+ // This may be informative, e.g. division by zero etc...
+ ""
+ tagText t
+
+ let any_to_layout opts (x, xty) =
+ let formatter = ObjectGraphFormatter(opts, BindingFlags.Public)
+ formatter.Format(ShowAll, x, xty)
+
+ let squashTo maxWidth layout =
+ layout |> squashToAux (maxWidth, leafFormatter FormatOptions.Default)
+
+ let squash_layout opts l =
+ // Print width = 0 implies 1D layout, no squash
+ if opts.PrintWidth = 0 then
+ l
+ else
+ l |> squashToAux (opts.PrintWidth,leafFormatter opts)
+
+ let asTaggedTextWriter (tw: TextWriter) =
+ { new TaggedTextWriter with
+ member __.Write(t) = tw.Write t.Text
+ member __.WriteLine() = tw.WriteLine() }
+
+ let output_layout_tagged opts oc l =
+ l |> squash_layout opts
+ |> outL opts.AttributeProcessor (leafFormatter opts) oc
+
+ let output_layout opts oc l =
+ output_layout_tagged opts (asTaggedTextWriter oc) l
+
+ let layout_to_string options layout =
+ layout |> squash_layout options
+ |> showL options ((leafFormatter options) >> toText)
+
+ let output_any_ex opts oc x = x |> any_to_layout opts |> output_layout opts oc
+
+ let output_any writer x = output_any_ex FormatOptions.Default writer x
+
+ let layout_as_string opts x = x |> any_to_layout opts |> layout_to_string opts
+
+ let any_to_string x = layout_as_string FormatOptions.Default x
#if COMPILER
- /// Called
- let fsi_any_to_layout opts x = anyL ShowTopLevelBinding BindingFlags.Public opts x
+ let fsi_any_to_layout opts (x, xty) =
+ let formatter = ObjectGraphFormatter(opts, BindingFlags.Public)
+ formatter.Format (ShowTopLevelBinding, x, xty)
#else
-// FSharp.Core
- let internal anyToStringForPrintf options (bindingFlags:BindingFlags) x =
- x |> anyL ShowAll bindingFlags options |> layout_to_string options
+ let internal anyToStringForPrintf options (bindingFlags:BindingFlags) (x, xty) =
+ let formatter = ObjectGraphFormatter(options, bindingFlags)
+ formatter.Format (ShowAll, x, xty) |> layout_to_string options
#endif
diff --git a/src/utils/sformat.fsi b/src/utils/sformat.fsi
index e6ff9762bb5..da5b4219fb5 100644
--- a/src/utils/sformat.fsi
+++ b/src/utils/sformat.fsi
@@ -29,10 +29,13 @@ namespace Microsoft.FSharp.Text.StructuredPrintfImpl
open Microsoft.FSharp.Collections
open Microsoft.FSharp.Primitives.Basics
+#if FSHARP_CORE
/// Data representing structured layouts of terms.
-#if FSHARP_CORE // FSharp.Core.dll makes things internal and hides representations
+ // FSharp.Core.dll makes things internal and hides representations
type internal Layout
+
type internal LayoutTag
+
type internal TaggedText =
abstract Tag: LayoutTag
abstract Text: string
@@ -43,8 +46,8 @@ namespace Microsoft.FSharp.Text.StructuredPrintfImpl
[]
type public Joint =
| Unbreakable
- | Breakable of int
- | Broken of int
+ | Breakable of indentation: int
+ | Broken of indentation: int
[]
type public LayoutTag =
@@ -83,8 +86,8 @@ namespace Microsoft.FSharp.Text.StructuredPrintfImpl
| UnknownEntity
type public TaggedText =
- abstract Tag : LayoutTag
- abstract Text : string
+ abstract Tag: LayoutTag
+ abstract Text: string
type public TaggedTextWriter =
@@ -95,10 +98,12 @@ namespace Microsoft.FSharp.Text.StructuredPrintfImpl
/// of this data type is only for the consumption of formatting engines.
[]
type public Layout =
- | ObjLeaf of bool * obj * bool
- | Leaf of bool * TaggedText * bool
- | Node of bool * Layout * bool * Layout * bool * Joint
- | Attr of string * (string * string) list * Layout
+ | ObjLeaf of juxtLeft: bool * object: obj * juxtRight: bool
+ | Leaf of juxtLeft: bool * text: TaggedText * justRight: bool
+ | Node of leftLayout: Layout * rightLayout: Layout * joint: Joint
+ | Attr of text: string * attributes: (string * string) list * layout: Layout
+
+ static member JuxtapositionMiddle: left: Layout * right: Layout -> bool
#endif
#if COMPILER
@@ -106,66 +111,68 @@ namespace Microsoft.FSharp.Text.StructuredPrintfImpl
#else
module internal TaggedTextOps =
#endif
- val tag : LayoutTag -> string -> TaggedText
- val keywordFunctions : Set
- val tagAlias : string -> TaggedText
- val tagClass : string -> TaggedText
- val tagUnionCase : string -> TaggedText
- val tagDelegate : string -> TaggedText
- val tagEnum : string -> TaggedText
- val tagEvent : string -> TaggedText
- val tagField : string -> TaggedText
- val tagInterface : string -> TaggedText
- val tagKeyword : string -> TaggedText
- val tagLineBreak : string -> TaggedText
- val tagMethod : string -> TaggedText
- val tagModuleBinding : string -> TaggedText
- val tagLocal : string -> TaggedText
- val tagRecord : string -> TaggedText
- val tagRecordField : string -> TaggedText
- val tagModule : string -> TaggedText
- val tagNamespace : string -> TaggedText
- val tagNumericLiteral : string -> TaggedText
- val tagOperator : string -> TaggedText
- val tagParameter : string -> TaggedText
- val tagProperty : string -> TaggedText
- val tagSpace : string -> TaggedText
- val tagStringLiteral : string -> TaggedText
- val tagStruct : string -> TaggedText
- val tagTypeParameter : string -> TaggedText
- val tagText : string -> TaggedText
- val tagPunctuation : string -> TaggedText
+ val mkTag: LayoutTag -> string -> TaggedText
+ val keywordFunctions: Set
+ val tagAlias: string -> TaggedText
+ val tagClass: string -> TaggedText
+ val tagUnionCase: string -> TaggedText
+ val tagDelegate: string -> TaggedText
+ val tagEnum: string -> TaggedText
+ val tagEvent: string -> TaggedText
+ val tagField: string -> TaggedText
+ val tagInterface: string -> TaggedText
+ val tagKeyword: string -> TaggedText
+ val tagLineBreak: string -> TaggedText
+ val tagMethod: string -> TaggedText
+ val tagModuleBinding: string -> TaggedText
+ val tagLocal: string -> TaggedText
+ val tagRecord: string -> TaggedText
+ val tagRecordField: string -> TaggedText
+ val tagModule: string -> TaggedText
+ val tagNamespace: string -> TaggedText
+ val tagNumericLiteral: string -> TaggedText
+ val tagOperator: string -> TaggedText
+ val tagParameter: string -> TaggedText
+ val tagProperty: string -> TaggedText
+ val tagSpace: string -> TaggedText
+ val tagStringLiteral: string -> TaggedText
+ val tagStruct: string -> TaggedText
+ val tagTypeParameter: string -> TaggedText
+ val tagText: string -> TaggedText
+ val tagPunctuation: string -> TaggedText
module Literals =
// common tagged literals
- val lineBreak : TaggedText
- val space : TaggedText
- val comma : TaggedText
- val semicolon : TaggedText
- val leftParen : TaggedText
- val rightParen : TaggedText
- val leftBracket : TaggedText
- val rightBracket : TaggedText
+ val lineBreak: TaggedText
+ val space: TaggedText
+ val comma: TaggedText
+ val semicolon: TaggedText
+ val leftParen: TaggedText
+ val rightParen: TaggedText
+ val leftBracket: TaggedText
+ val rightBracket: TaggedText
val leftBrace: TaggedText
- val rightBrace : TaggedText
+ val rightBrace: TaggedText
val leftBraceBar: TaggedText
- val rightBraceBar : TaggedText
- val equals : TaggedText
- val arrow : TaggedText
- val questionMark : TaggedText
+ val rightBraceBar: TaggedText
+ val equals: TaggedText
+ val arrow: TaggedText
+ val questionMark: TaggedText
#if COMPILER
type public IEnvironment =
/// Return to the layout-generation
/// environment to layout any otherwise uninterpreted object
- abstract GetLayout : obj -> Layout
+ abstract GetLayout: obj -> Layout
+
/// The maximum number of elements for which to generate layout for
/// list-like structures, or columns in table-like
/// structures. -1 if no maximum.
- abstract MaxColumns : int
+ abstract MaxColumns: int
+
/// The maximum number of rows for which to generate layout for table-like
/// structures. -1 if no maximum.
- abstract MaxRows : int
+ abstract MaxRows: int
#endif
/// A layout is a sequence of strings which have been joined together.
@@ -181,92 +188,92 @@ namespace Microsoft.FSharp.Text.StructuredPrintfImpl
#endif
/// The empty layout
- val emptyL : Layout
+ val emptyL : Layout
/// Is it the empty layout?
- val isEmptyL : layout:Layout -> bool
+ val isEmptyL: layout:Layout -> bool
/// An uninterpreted leaf, to be interpreted into a string
/// by the layout engine. This allows leaf layouts for numbers, strings and
/// other atoms to be customized according to culture.
- val objL : value:obj -> Layout
+ val objL : value:obj -> Layout
/// An string leaf
- val wordL : text:TaggedText -> Layout
+ val wordL : text:TaggedText -> Layout
/// An string which requires no spaces either side.
- val sepL : text:TaggedText -> Layout
+ val sepL : text:TaggedText -> Layout
/// An string which is right parenthesis (no space on the left).
- val rightL : text:TaggedText -> Layout
+ val rightL : text:TaggedText -> Layout
/// An string which is left parenthesis (no space on the right).
- val leftL : text:TaggedText -> Layout
+ val leftL : text:TaggedText -> Layout
/// Join, unbreakable.
- val ( ^^ ) : layout1:Layout -> layout2:Layout -> Layout
+ val ( ^^ ) : layout1:Layout -> layout2:Layout -> Layout
/// Join, possible break with indent=0
- val ( ++ ) : layout1:Layout -> layout2:Layout -> Layout
+ val ( ++ ) : layout1:Layout -> layout2:Layout -> Layout
/// Join, possible break with indent=1
- val ( -- ) : layout1:Layout -> layout2:Layout -> Layout
+ val ( -- ) : layout1:Layout -> layout2:Layout -> Layout
/// Join, possible break with indent=2
- val ( --- ) : layout1:Layout -> layout2:Layout -> Layout
+ val ( --- ): layout1:Layout -> layout2:Layout -> Layout
/// Join broken with ident=0
- val ( @@ ) : layout1:Layout -> layout2:Layout -> Layout
+ val ( @@ ) : layout1:Layout -> layout2:Layout -> Layout
/// Join broken with ident=1
- val ( @@- ) : layout1:Layout -> layout2:Layout -> Layout
+ val ( @@- ): layout1:Layout -> layout2:Layout -> Layout
/// Join broken with ident=2
- val ( @@-- ) : layout1:Layout -> layout2:Layout -> Layout
+ val ( @@-- ): layout1:Layout -> layout2:Layout -> Layout
/// Join layouts into a comma separated list.
- val commaListL : layouts:Layout list -> Layout
+ val commaListL: layouts:Layout list -> Layout
/// Join layouts into a space separated list.
- val spaceListL : layouts:Layout list -> Layout
+ val spaceListL: layouts:Layout list -> Layout
/// Join layouts into a semi-colon separated list.
- val semiListL : layouts:Layout list -> Layout
+ val semiListL: layouts:Layout list -> Layout
/// Join layouts into a list separated using the given Layout.
- val sepListL : layout1:Layout -> layouts:Layout list -> Layout
+ val sepListL: layout1:Layout -> layouts:Layout list -> Layout
/// Wrap round brackets around Layout.
- val bracketL : layout:Layout -> Layout
+ val bracketL: layout:Layout -> Layout
/// Wrap square brackets around layout.
- val squareBracketL : layout:Layout -> Layout
+ val squareBracketL: layout:Layout -> Layout
/// Wrap braces around layout.
- val braceL : layout:Layout -> Layout
+ val braceL : layout:Layout -> Layout
/// Form tuple of layouts.
- val tupleL : layouts:Layout list -> Layout
+ val tupleL : layouts:Layout list -> Layout
/// Layout two vertically.
- val aboveL : layout1:Layout -> layout2:Layout -> Layout
+ val aboveL : layout1:Layout -> layout2:Layout -> Layout
/// Layout list vertically.
- val aboveListL : layouts:Layout list -> Layout
+ val aboveListL: layouts:Layout list -> Layout
/// Layout like an F# option.
- val optionL : selector:('T -> Layout) -> value:'T option -> Layout
+ val optionL: selector:('T -> Layout) -> value:'T option -> Layout
/// Layout like an F# list.
- val listL : selector:('T -> Layout) -> value:'T list -> Layout
+ val listL : selector:('T -> Layout) -> value:'T list -> Layout
/// See tagL
- val tagAttrL : text:string -> maps:(string * string) list -> layout:Layout -> Layout
+ val tagAttrL: text:string -> maps:(string * string) list -> layout:Layout -> Layout
/// For limiting layout of list-like sequences (lists,arrays,etc).
/// unfold a list of items using (project and z) making layout list via itemL.
/// If reach maxLength (before exhausting) then truncate.
- val unfoldL : selector:('T -> Layout) -> folder:('State -> ('T * 'State) option) -> state:'State -> count:int -> Layout list
+ val unfoldL: selector:('T -> Layout) -> folder:('State -> ('T * 'State) option) -> state:'State -> count:int -> Layout list
/// A record of options to control structural formatting.
/// For F# Interactive properties matching those of this value can be accessed via the 'fsi'
@@ -296,20 +303,21 @@ namespace Microsoft.FSharp.Text.StructuredPrintfImpl
type internal FormatOptions =
#endif
{ FloatingPointFormat: string
- AttributeProcessor: (string -> (string * string) list -> bool -> unit);
+ AttributeProcessor: (string -> (string * string) list -> bool -> unit)
#if COMPILER // FSharp.Core.dll: PrintIntercepts aren't used there
- PrintIntercepts: (IEnvironment -> obj -> Layout option) list;
- StringLimit: int;
+ PrintIntercepts: (IEnvironment -> obj -> Layout option) list
+ StringLimit: int
#endif
FormatProvider: System.IFormatProvider
BindingFlags: System.Reflection.BindingFlags
- PrintWidth : int
- PrintDepth : int
- PrintLength : int
- PrintSize : int
- ShowProperties : bool
+ PrintWidth: int
+ PrintDepth: int
+ PrintLength: int
+ PrintSize: int
+ ShowProperties: bool
ShowIEnumerable: bool }
- static member Default : FormatOptions
+
+ static member Default: FormatOptions
#if COMPILER
module public Display =
@@ -317,33 +325,24 @@ namespace Microsoft.FSharp.Text.StructuredPrintfImpl
module internal Display =
#endif
- /// Convert any value to a string using a standard formatter
- /// Data is typically formatted in a structured format, e.g.
- /// lists are formatted using the "[1;2]" notation.
- /// The details of the format are not specified and may change
- /// from version to version and according to the flags given
- /// to the F# compiler. The format is intended to be human-readable,
- /// not machine readable. If alternative generic formats are required
- /// you should develop your own formatter, using the code in the
- /// implementation of this file as a starting point.
- ///
- /// Data from other .NET languages is formatted using a virtual
- /// call to Object.ToString() on the boxed version of the input.
- val any_to_string: value:'T * Type -> string
-
- /// Output any value to a channel using the same set of formatting rules
- /// as any_to_string
- val output_any: writer:TextWriter -> value:'T * Type -> unit
-
-#if FSHARP_CORE // FSharp.Core.dll: Most functions aren't needed in FSharp.Core.dll, but we add one entry for printf
+#if FSHARP_CORE
+ // Most functions aren't needed in FSharp.Core.dll, but we add one inernal entry for printf
val anyToStringForPrintf: options:FormatOptions -> bindingFlags:System.Reflection.BindingFlags -> value:'T * Type -> string
#else
+
val asTaggedTextWriter: writer: TextWriter -> TaggedTextWriter
- val any_to_layout : options:FormatOptions -> value:'T * Type -> Layout
- val squash_layout : options:FormatOptions -> layout:Layout -> Layout
- val output_layout_tagged : options:FormatOptions -> writer:TaggedTextWriter -> layout:Layout -> unit
- val output_layout : options:FormatOptions -> writer:TextWriter -> layout:Layout -> unit
+
+ val any_to_layout: options:FormatOptions -> value:'T * Type -> Layout
+
+ val squashTo: width: int -> layout: Layout -> Layout
+
+ val squash_layout: options:FormatOptions -> layout:Layout -> Layout
+
+ val output_layout_tagged: options:FormatOptions -> writer:TaggedTextWriter -> layout:Layout -> unit
+
+ val output_layout: options:FormatOptions -> writer:TextWriter -> layout:Layout -> unit
+
val layout_as_string: options:FormatOptions -> value:'T * Type -> string
#endif
@@ -353,7 +352,6 @@ namespace Microsoft.FSharp.Text.StructuredPrintfImpl
/// built using any_to_layout with default format options.
val layout_to_string: options:FormatOptions -> layout:Layout -> string
-
#if COMPILER
- val fsi_any_to_layout : options:FormatOptions -> value:'T * Type -> Layout
+ val fsi_any_to_layout: options:FormatOptions -> value:'T * Type -> Layout
#endif
diff --git a/tests/Directory.Build.targets b/tests/Directory.Build.targets
index 1108759d4a2..14437118703 100644
--- a/tests/Directory.Build.targets
+++ b/tests/Directory.Build.targets
@@ -1,16 +1,3 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/tests/FSharp.Compiler.ComponentTests/xunit.runner.json b/tests/FSharp.Compiler.ComponentTests/xunit.runner.json
index aa4e627f2b8..d60e5705290 100644
--- a/tests/FSharp.Compiler.ComponentTests/xunit.runner.json
+++ b/tests/FSharp.Compiler.ComponentTests/xunit.runner.json
@@ -1,4 +1,5 @@
{
"$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
+ "appDomain": "denied",
"shadowCopy": false
}
diff --git a/tests/FSharp.Compiler.Private.Scripting.UnitTests/CompletionTests.fs b/tests/FSharp.Compiler.Private.Scripting.UnitTests/CompletionTests.fs
index 03935ee77f0..89c4cc20116 100644
--- a/tests/FSharp.Compiler.Private.Scripting.UnitTests/CompletionTests.fs
+++ b/tests/FSharp.Compiler.Private.Scripting.UnitTests/CompletionTests.fs
@@ -5,12 +5,11 @@ namespace FSharp.Compiler.Scripting.UnitTests
open System
open System.Threading.Tasks
open FSharp.Compiler.Scripting
-open NUnit.Framework
+open Xunit
-[]
type CompletionTests() =
- []
+ []
member _.``Instance completions in the same submission``() =
async {
use script = new FSharpScript()
@@ -18,20 +17,20 @@ type CompletionTests() =
"x." ]
let! completions = script.GetCompletionItems(String.Join("\n", lines), 2, 2)
let matchingCompletions = completions |> Array.filter (fun d -> d.Name = "CompareTo")
- Assert.AreEqual(1, matchingCompletions.Length)
+ Assert.Equal(1, matchingCompletions.Length)
} |> Async.StartAsTask :> Task
- []
+ []
member _.``Instance completions from a previous submission``() =
async {
use script = new FSharpScript()
script.Eval("let x = 1") |> ignoreValue
let! completions = script.GetCompletionItems("x.", 1, 2)
let matchingCompletions = completions |> Array.filter (fun d -> d.Name = "CompareTo")
- Assert.AreEqual(1, matchingCompletions.Length)
+ Assert.Equal(1, matchingCompletions.Length)
} |> Async.StartAsTask :> Task
- []
+ []
member _.``Completions from types that try to pull in Windows runtime extensions``() =
async {
use script = new FSharpScript()
@@ -39,37 +38,37 @@ type CompletionTests() =
script.Eval("let t = TimeSpan.FromHours(1.0)") |> ignoreValue
let! completions = script.GetCompletionItems("t.", 1, 2)
let matchingCompletions = completions |> Array.filter (fun d -> d.Name = "TotalHours")
- Assert.AreEqual(1, matchingCompletions.Length)
+ Assert.Equal(1, matchingCompletions.Length)
} |> Async.StartAsTask :> Task
- []
+ []
member _.``Static member completions``() =
async {
use script = new FSharpScript()
let! completions = script.GetCompletionItems("System.String.", 1, 14)
let matchingCompletions = completions |> Array.filter (fun d -> d.Name = "Join")
- Assert.GreaterOrEqual(matchingCompletions.Length, 1)
+ Assert.True(matchingCompletions.Length >= 1)
} |> Async.StartAsTask :> Task
- []
+ []
member _.``Type completions from namespace``() =
async {
use script = new FSharpScript()
let! completions = script.GetCompletionItems("System.", 1, 7)
let matchingCompletions = completions |> Array.filter (fun d -> d.Name = "String")
- Assert.GreaterOrEqual(matchingCompletions.Length, 1)
+ Assert.True(matchingCompletions.Length >= 1)
} |> Async.StartAsTask :> Task
- []
+ []
member _.``Namespace completions``() =
async {
use script = new FSharpScript()
let! completions = script.GetCompletionItems("System.", 1, 7)
let matchingCompletions = completions |> Array.filter (fun d -> d.Name = "Collections")
- Assert.AreEqual(1, matchingCompletions.Length)
+ Assert.Equal(1, matchingCompletions.Length)
} |> Async.StartAsTask :> Task
- []
+ []
member _.``Extension method completions``() =
async {
use script = new FSharpScript()
@@ -78,5 +77,5 @@ type CompletionTests() =
"list." ]
let! completions = script.GetCompletionItems(String.Join("\n", lines), 3, 5)
let matchingCompletions = completions |> Array.filter (fun d -> d.Name = "Select")
- Assert.AreEqual(1, matchingCompletions.Length)
+ Assert.Equal(1, matchingCompletions.Length)
} |> Async.StartAsTask :> Task
diff --git a/tests/FSharp.Compiler.Private.Scripting.UnitTests/DependencyManagerInteractiveTests.fs b/tests/FSharp.Compiler.Private.Scripting.UnitTests/DependencyManagerInteractiveTests.fs
index 02b03e9b4b8..a2659d1dcbd 100644
--- a/tests/FSharp.Compiler.Private.Scripting.UnitTests/DependencyManagerInteractiveTests.fs
+++ b/tests/FSharp.Compiler.Private.Scripting.UnitTests/DependencyManagerInteractiveTests.fs
@@ -7,20 +7,20 @@ open System.Collections.Generic
open System.IO
open System.Reflection
open System.Runtime.InteropServices
+open System.Threading
+
open FSharp.Compiler.Interactive.Shell
open FSharp.Compiler.Scripting
open FSharp.Compiler.SourceCodeServices
-open System.Runtime.InteropServices
-open NUnit.Framework
-open Microsoft.DotNet.DependencyManager
open FSharp.Compiler.Scripting.UnitTests
-open System.Threading
+open Microsoft.DotNet.DependencyManager
+
+open Xunit
module Native =
[]
extern int NoneSuch()
-[]
type DependencyManagerInteractiveTests() =
let getValue ((value: Result), (errors: FSharpErrorInfo[])) =
@@ -34,7 +34,7 @@ type DependencyManagerInteractiveTests() =
let scriptHost () = new FSharpScript(additionalArgs=[|"/langversion:preview"|])
- []
+ []
member __.``SmokeTest - #r nuget``() =
let text = """
#r @"nuget:Newtonsoft.Json, Version=9.0.1"
@@ -42,10 +42,10 @@ type DependencyManagerInteractiveTests() =
use script = scriptHost()
let opt = script.Eval(text) |> getValue
let value = opt.Value
- Assert.AreEqual(typeof, value.ReflectionType)
- Assert.AreEqual(0, value.ReflectionValue :?> int)
+ Assert.Equal(typeof, value.ReflectionType)
+ Assert.Equal(0, value.ReflectionValue :?> int)
- []
+ []
member __.``SmokeTest - #r nuget package not found``() =
let text = """
#r @"nuget:System.Collections.Immutable.DoesNotExist, version=1.5.0"
@@ -53,10 +53,10 @@ type DependencyManagerInteractiveTests() =
use script = scriptHost()
let opt = script.Eval(text) |> getValue
let value = opt.Value
- Assert.AreEqual(typeof, value.ReflectionType)
- Assert.AreEqual(0, value.ReflectionValue :?> int)
+ Assert.Equal(typeof, value.ReflectionType)
+ Assert.Equal(0, value.ReflectionValue :?> int)
- []
+ []
member __.``Use Dependency Manager to resolve dependency FSharp.Data``() =
let nativeProbingRoots () = Seq.empty
@@ -73,20 +73,20 @@ type DependencyManagerInteractiveTests() =
if RuntimeInformation.IsOSPlatform(OSPlatform.Windows) then
let result = dp.Resolve(idm, ".fsx", [|"FSharp.Data"|], reportError, "net472")
- Assert.AreEqual(true, result.Success)
- Assert.AreEqual(1, result.Resolutions |> Seq.length)
- Assert.AreEqual(1, result.SourceFiles |> Seq.length)
- Assert.AreEqual(1, result.Roots |> Seq.length)
+ Assert.Equal(true, result.Success)
+ Assert.Equal(1, result.Resolutions |> Seq.length)
+ Assert.Equal(1, result.SourceFiles |> Seq.length)
+ Assert.Equal(1, result.Roots |> Seq.length)
let result = dp.Resolve(idm, ".fsx", [|"FSharp.Data"|], reportError, "netcoreapp3.1")
- Assert.AreEqual(true, result.Success)
- Assert.AreEqual(1, result.Resolutions |> Seq.length)
- Assert.AreEqual(1, result.SourceFiles |> Seq.length)
- Assert.AreEqual(1, result.Roots |> Seq.length)
+ Assert.Equal(true, result.Success)
+ Assert.Equal(1, result.Resolutions |> Seq.length)
+ Assert.Equal(1, result.SourceFiles |> Seq.length)
+ Assert.Equal(1, result.Roots |> Seq.length)
()
- []
+ []
member __.``Dependency add with nonexistent package should fail``() =
let nativeProbingRoots () = Seq.empty
@@ -103,20 +103,20 @@ type DependencyManagerInteractiveTests() =
if RuntimeInformation.IsOSPlatform(OSPlatform.Windows) then
let result = dp.Resolve(idm, ".fsx", [|"System.Collections.Immutable.DoesNotExist"|], reportError, "net472")
- Assert.AreEqual(false, result.Success)
- Assert.AreEqual(0, result.Resolutions |> Seq.length)
- Assert.AreEqual(0, result.SourceFiles |> Seq.length)
- Assert.AreEqual(0, result.Roots |> Seq.length)
+ Assert.Equal(false, result.Success)
+ Assert.Equal(0, result.Resolutions |> Seq.length)
+ Assert.Equal(0, result.SourceFiles |> Seq.length)
+ Assert.Equal(0, result.Roots |> Seq.length)
let result = dp.Resolve(idm, ".fsx", [|"System.Collections.Immutable.DoesNotExist"|], reportError, "netcoreapp3.1")
- Assert.AreEqual(false, result.Success)
- Assert.AreEqual(0, result.Resolutions |> Seq.length)
- Assert.AreEqual(0, result.SourceFiles |> Seq.length)
- Assert.AreEqual(0, result.Roots |> Seq.length)
+ Assert.Equal(false, result.Success)
+ Assert.Equal(0, result.Resolutions |> Seq.length)
+ Assert.Equal(0, result.SourceFiles |> Seq.length)
+ Assert.Equal(0, result.Roots |> Seq.length)
()
- []
+ []
member __.``Multiple Instances of DependencyProvider should be isolated``() =
let assemblyProbingPaths () = Seq.empty
@@ -133,53 +133,53 @@ type DependencyManagerInteractiveTests() =
let idm1 = dp1.TryFindDependencyManagerByKey(Seq.empty, "", reportError, "nuget")
if RuntimeInformation.IsOSPlatform(OSPlatform.Windows) then
let result1 = dp1.Resolve(idm1, ".fsx", [|"FSharp.Data"|], reportError, "net472")
- Assert.AreEqual(true, result1.Success)
- Assert.AreEqual(1, result1.Resolutions |> Seq.length)
- Assert.IsTrue((result1.Resolutions |> Seq.head).Contains("\\net45\\"))
- Assert.AreEqual(1, result1.SourceFiles |> Seq.length)
- Assert.AreEqual(1, result1.Roots |> Seq.length)
- Assert.IsTrue((result1.Roots |> Seq.head).EndsWith("/fsharp.data/3.3.3/"))
+ Assert.Equal(true, result1.Success)
+ Assert.Equal(1, result1.Resolutions |> Seq.length)
+ Assert.True((result1.Resolutions |> Seq.head).Contains("\\net45\\"))
+ Assert.Equal(1, result1.SourceFiles |> Seq.length)
+ Assert.Equal(1, result1.Roots |> Seq.length)
+ Assert.True((result1.Roots |> Seq.head).EndsWith("/fsharp.data/3.3.3/"))
let result2 = dp1.Resolve(idm1, ".fsx", [|"FSharp.Data, 3.3.3"|], reportError, "netcoreapp3.1")
- Assert.AreEqual(true, result2.Success)
- Assert.AreEqual(1, result2.Resolutions |> Seq.length)
+ Assert.Equal(true, result2.Success)
+ Assert.Equal(1, result2.Resolutions |> Seq.length)
let expected2 =
if RuntimeInformation.IsOSPlatform(OSPlatform.Windows) then
"\\netstandard2.0\\"
else
"/netstandard2.0/"
- Assert.IsTrue((result2.Resolutions |> Seq.head).Contains(expected2))
- Assert.AreEqual(1, result2.SourceFiles |> Seq.length)
- Assert.AreEqual(1, result2.Roots |> Seq.length)
- Assert.IsTrue((result2.Roots |> Seq.head).EndsWith("/fsharp.data/3.3.3/"))
+ Assert.True((result2.Resolutions |> Seq.head).Contains(expected2))
+ Assert.Equal(1, result2.SourceFiles |> Seq.length)
+ Assert.Equal(1, result2.Roots |> Seq.length)
+ Assert.True((result2.Roots |> Seq.head).EndsWith("/fsharp.data/3.3.3/"))
use dp2 = new DependencyProvider(NativeResolutionProbe(nativeProbingRoots))
let idm2 = dp2.TryFindDependencyManagerByKey(Seq.empty, "", reportError, "nuget")
if RuntimeInformation.IsOSPlatform(OSPlatform.Windows) then
let result3 = dp2.Resolve(idm2, ".fsx", [|"System.Json, Version=4.6.0"|], reportError, "net472")
- Assert.AreEqual(true, result3.Success)
- Assert.AreEqual(1, result3.Resolutions |> Seq.length)
- Assert.IsTrue((result3.Resolutions |> Seq.head).Contains("\\netstandard2.0\\"))
- Assert.AreEqual(1, result3.SourceFiles |> Seq.length)
- Assert.AreEqual(1, result3.SourceFiles |> Seq.length)
- Assert.IsTrue((result3.Roots |> Seq.head).EndsWith("/system.json/4.6.0/"))
+ Assert.Equal(true, result3.Success)
+ Assert.Equal(1, result3.Resolutions |> Seq.length)
+ Assert.True((result3.Resolutions |> Seq.head).Contains("\\netstandard2.0\\"))
+ Assert.Equal(1, result3.SourceFiles |> Seq.length)
+ Assert.Equal(1, result3.SourceFiles |> Seq.length)
+ Assert.True((result3.Roots |> Seq.head).EndsWith("/system.json/4.6.0/"))
let result4 = dp2.Resolve(idm2, ".fsx", [|"System.Json, Version=4.6.0"|], reportError, "netcoreapp3.1")
- Assert.AreEqual(true, result4.Success)
- Assert.AreEqual(1, result4.Resolutions |> Seq.length)
+ Assert.Equal(true, result4.Success)
+ Assert.Equal(1, result4.Resolutions |> Seq.length)
let expected4 =
if RuntimeInformation.IsOSPlatform(OSPlatform.Windows) then
"\\netstandard2.0\\"
else
"/netstandard2.0/"
- Assert.IsTrue((result4.Resolutions |> Seq.head).Contains(expected4))
- Assert.AreEqual(1, result4.SourceFiles |> Seq.length)
- Assert.AreEqual(1, result4.Roots |> Seq.length)
- Assert.IsTrue((result4.Roots |> Seq.head).EndsWith("/system.json/4.6.0/"))
+ Assert.True((result4.Resolutions |> Seq.head).Contains(expected4))
+ Assert.Equal(1, result4.SourceFiles |> Seq.length)
+ Assert.Equal(1, result4.Roots |> Seq.length)
+ Assert.True((result4.Roots |> Seq.head).EndsWith("/system.json/4.6.0/"))
()
- []
+ []
member __.``Nuget Reference package with dependencies we should get package roots and dependent references``() =
let nativeProbingRoots () = Seq.empty
@@ -196,32 +196,32 @@ type DependencyManagerInteractiveTests() =
if RuntimeInformation.IsOSPlatform(OSPlatform.Windows) then
let result1 = dp1.Resolve(idm1, ".fsx", [|"Microsoft.Extensions.Configuration.Abstractions, 3.1.1"|], reportError, "net472")
- Assert.AreEqual(true, result1.Success)
- Assert.AreEqual(6, result1.Resolutions |> Seq.length)
- Assert.IsTrue((result1.Resolutions |> Seq.head).Contains("\\netstandard2.0\\"))
- Assert.AreEqual(1, result1.SourceFiles |> Seq.length)
- Assert.AreEqual(6, result1.Roots |> Seq.length)
- Assert.IsTrue((result1.Roots |> Seq.head).EndsWith("/microsoft.extensions.configuration.abstractions/3.1.1/"))
+ Assert.Equal(true, result1.Success)
+ Assert.Equal(6, result1.Resolutions |> Seq.length)
+ Assert.True((result1.Resolutions |> Seq.head).Contains("\\netstandard2.0\\"))
+ Assert.Equal(1, result1.SourceFiles |> Seq.length)
+ Assert.Equal(6, result1.Roots |> Seq.length)
+ Assert.True((result1.Roots |> Seq.head).EndsWith("/microsoft.extensions.configuration.abstractions/3.1.1/"))
// Netstandard gets fewer dependencies than desktop, because desktop framework doesn't contain assemblies like System.Memory
// Those assemblies must be delivered by nuget for desktop apps
let result2 = dp1.Resolve(idm1, ".fsx", [|"Microsoft.Extensions.Configuration.Abstractions, 3.1.1"|], reportError, "netcoreapp3.1")
- Assert.AreEqual(true, result2.Success)
- Assert.AreEqual(2, result2.Resolutions |> Seq.length)
+ Assert.Equal(true, result2.Success)
+ Assert.Equal(2, result2.Resolutions |> Seq.length)
let expected =
if RuntimeInformation.IsOSPlatform(OSPlatform.Windows) then
"\\netcoreapp3.1\\"
else
"/netcoreapp3.1/"
- Assert.IsTrue((result2.Resolutions |> Seq.head).Contains(expected))
- Assert.AreEqual(1, result2.SourceFiles |> Seq.length)
- Assert.AreEqual(2, result2.Roots |> Seq.length)
- Assert.IsTrue((result2.Roots |> Seq.head).EndsWith("/microsoft.extensions.configuration.abstractions/3.1.1/"))
+ Assert.True((result2.Resolutions |> Seq.head).Contains(expected))
+ Assert.Equal(1, result2.SourceFiles |> Seq.length)
+ Assert.Equal(2, result2.Roots |> Seq.length)
+ Assert.True((result2.Roots |> Seq.head).EndsWith("/microsoft.extensions.configuration.abstractions/3.1.1/"))
()
/// Native dll resolution is not implemented on desktop
#if NETCOREAPP
- []
+ []
member __.``Script using TorchSharp``() =
let text = """
#r "nuget:RestoreSources=https://donsyme.pkgs.visualstudio.com/TorchSharp/_packaging/packages2/nuget/v3/index.json"
@@ -235,12 +235,12 @@ TorchSharp.Tensor.LongTensor.From([| 0L .. 100L |]).Device
use script = scriptHost()
let opt = script.Eval(text) |> getValue
let value = opt.Value
- Assert.AreEqual(typeof, value.ReflectionType)
- Assert.AreEqual("cpu", value.ReflectionValue :?> string)
+ Assert.Equal(typeof, value.ReflectionType)
+ Assert.Equal("cpu", value.ReflectionValue :?> string)
()
- []
+ []
member __.``Use Dependency Manager to restore packages with native dependencies, build and run script that depends on the results``() =
let packagemanagerlines = [|
"RestoreSources=https://dotnet.myget.org/F/dotnet-corefxlab/api/v3/index.json"
@@ -269,7 +269,7 @@ TorchSharp.Tensor.LongTensor.From([| 0L .. 100L |]).Device
let idm = dp.TryFindDependencyManagerByKey(Seq.empty, "", reportError, "nuget")
dp.Resolve(idm, ".fsx", packagemanagerlines, reportError, "netcoreapp3.1")
- Assert.IsTrue(result.Success, "resolve failed")
+ Assert.True(result.Success, "resolve failed")
resolverPackageRoots <- result.Roots
resolverReferences <- result.Resolutions
@@ -335,9 +335,9 @@ printfn ""%A"" result
use script = new FSharpScript()
let opt = script.Eval(scriptText) |> getValue
let value = opt.Value
- Assert.AreEqual(123, value.ReflectionValue :?> int32)
+ Assert.Equal(123, value.ReflectionValue :?> int32)
- []
+ []
member __.``Use NativeResolver to resolve native dlls.``() =
let packagemanagerlines = [|
"RestoreSources=https://dotnet.myget.org/F/dotnet-corefxlab/api/v3/index.json"
@@ -366,7 +366,7 @@ printfn ""%A"" result
let idm = dp.TryFindDependencyManagerByKey(Seq.empty, "", reportError, "nuget")
dp.Resolve(idm, ".fsx", packagemanagerlines, reportError, "netcoreapp3.1")
- Assert.IsTrue(result.Success, "resolve failed")
+ Assert.True(result.Success, "resolve failed")
resolverPackageRoots <- result.Roots
resolverReferences <- result.Resolutions
@@ -418,9 +418,9 @@ printfn ""%A"" result
use script = new FSharpScript()
let opt = script.Eval(scriptText) |> getValue
let value = opt.Value
- Assert.AreEqual(123, value.ReflectionValue :?> int32)
+ Assert.Equal(123, value.ReflectionValue :?> int32)
- []
+ []
member __.``Use AssemblyResolver to resolve assemblies``() =
let packagemanagerlines = [|
"RestoreSources=https://dotnet.myget.org/F/dotnet-corefxlab/api/v3/index.json"
@@ -448,7 +448,7 @@ printfn ""%A"" result
let idm = dp.TryFindDependencyManagerByKey(Seq.empty, "", reportError, "nuget")
dp.Resolve(idm, ".fsx", packagemanagerlines, reportError, "netcoreapp3.1")
- Assert.IsTrue(result.Success, "resolve failed")
+ Assert.True(result.Success, "resolve failed")
resolverPackageRoots <- result.Roots
resolverReferences <- result.Resolutions
@@ -480,9 +480,9 @@ x |> Seq.iter(fun r ->
use script = new FSharpScript()
let opt = script.Eval(scriptText) |> getValue
let value = opt.Value
- Assert.AreEqual(123, value.ReflectionValue :?> int32)
+ Assert.Equal(123, value.ReflectionValue :?> int32)
- []
+ []
member __.``Verify that referencing FSharp.Core fails with FSharp Scripts``() =
let packagemanagerlines = [| "FSharp.Core,version=4.7.1" |]
@@ -506,9 +506,9 @@ x |> Seq.iter(fun r ->
dp.Resolve(idm, ".fsx", packagemanagerlines, reportError, "netcoreapp3.1")
// Expected: error FS3217: PackageManager can not reference the System Package 'FSharp.Core'
- Assert.IsFalse(result.Success, "resolve succeeded but should have failed")
+ Assert.False(result.Success, "resolve succeeded but should have failed")
- []
+ []
member __.``Verify that referencing FSharp.Core succeeds with CSharp Scripts``() =
let packagemanagerlines = [| "FSharp.Core,version=4.7.1" |]
@@ -531,10 +531,10 @@ x |> Seq.iter(fun r ->
let idm = dp.TryFindDependencyManagerByKey(Seq.empty, "", reportError, "nuget")
dp.Resolve(idm, ".csx", packagemanagerlines, reportError, "netcoreapp3.1")
- Assert.IsTrue(result.Success, "resolve failed but should have succeeded")
+ Assert.True(result.Success, "resolve failed but should have succeeded")
- []
+ []
member __.``Verify that Dispose on DependencyProvider unhooks ResolvingUnmanagedDll event handler``() =
let mutable found = false
@@ -555,32 +555,32 @@ x |> Seq.iter(fun r ->
// Invoking a non-existent dll via pinvoke cause a probe. which should invoke the call back
try Native.NoneSuch() |> ignore with _ -> ()
- Assert.IsTrue (found, "Failed to invoke the nativeProbingRoots callback")
+ Assert.True (found, "Failed to invoke the nativeProbingRoots callback")
// Here the dispose was invoked which should clear the ResolvingUnmanagedDll handler
found <- false
try Native.NoneSuch() |> ignore with _ -> ()
- Assert.IsFalse (found, "Invoke the nativeProbingRoots callback -- Error the ResolvingUnmanagedDll still fired ")
+ Assert.False (found, "Invoke the nativeProbingRoots callback -- Error the ResolvingUnmanagedDll still fired ")
use dp = new DependencyProvider(NativeResolutionProbe(nativeProbingRoots))
let idm = dp.TryFindDependencyManagerByKey(Seq.empty, "", reportError, "nuget")
if RuntimeInformation.IsOSPlatform(OSPlatform.Windows) then
let result = dp.Resolve(idm, ".fsx", [|"FSharp.Data"|], reportError, "net472")
- Assert.AreEqual(true, result.Success)
- Assert.AreEqual(1, result.Resolutions |> Seq.length)
- Assert.AreEqual(1, result.SourceFiles |> Seq.length)
- Assert.AreEqual(1, result.Roots |> Seq.length)
+ Assert.Equal(true, result.Success)
+ Assert.Equal(1, result.Resolutions |> Seq.length)
+ Assert.Equal(1, result.SourceFiles |> Seq.length)
+ Assert.Equal(1, result.Roots |> Seq.length)
let result = dp.Resolve(idm, ".fsx", [|"FSharp.Data"|], reportError, "netcoreapp3.1")
- Assert.AreEqual(true, result.Success)
- Assert.AreEqual(1, result.Resolutions |> Seq.length)
- Assert.AreEqual(1, result.SourceFiles |> Seq.length)
- Assert.AreEqual(1, result.Roots |> Seq.length)
+ Assert.Equal(true, result.Success)
+ Assert.Equal(1, result.Resolutions |> Seq.length)
+ Assert.Equal(1, result.SourceFiles |> Seq.length)
+ Assert.Equal(1, result.Roots |> Seq.length)
()
- []
+ []
member __.``Verify that Dispose on DependencyProvider unhooks ResolvingUnmanagedDll and AssemblyResolver event handler``() =
let mutable assemblyFound = false
@@ -599,24 +599,24 @@ x |> Seq.iter(fun r ->
// Invoking a non-existent dll via pinvoke cause a probe. which should invoke the call back
try Native.NoneSuch() |> ignore with _ -> ()
- Assert.IsTrue (nativeFound, "Failed to invoke the nativeProbingRoots callback")
+ Assert.True (nativeFound, "Failed to invoke the nativeProbingRoots callback")
// Invoking a non-existent assembly causes a probe. which should invoke the call back
try Assembly.Load("NoneSuchAssembly") |> ignore with _ -> ()
- Assert.IsTrue (assemblyFound, "Failed to invoke the AssemblyResolve handler")
+ Assert.True (assemblyFound, "Failed to invoke the AssemblyResolve handler")
// Here the dispose was invoked which should clear the ResolvingUnmanagedDll handler
nativeFound <- false
assemblyFound <- false
try Native.NoneSuch() |> ignore with _ -> ()
- Assert.IsFalse (nativeFound, "Invoke the nativeProbingRoots callback -- Error the ResolvingUnmanagedDll still fired ")
+ Assert.False (nativeFound, "Invoke the nativeProbingRoots callback -- Error the ResolvingUnmanagedDll still fired ")
try Assembly.Load("NoneSuchAssembly") |> ignore with _ -> ()
- Assert.IsFalse (assemblyFound, "Invoke the assemblyProbingRoots callback -- Error the AssemblyResolve still fired ")
+ Assert.False (assemblyFound, "Invoke the assemblyProbingRoots callback -- Error the AssemblyResolve still fired ")
#endif
- []
+ []
member __.``Verify that Dispose on AssemblyResolveHandler unhooks AssemblyResolve event handler``() =
let mutable assemblyFound = false
@@ -630,16 +630,16 @@ x |> Seq.iter(fun r ->
// Invoking a non-existent assembly causes a probe. which should invoke the call back
try Assembly.Load("NoneSuchAssembly") |> ignore with _ -> ()
- Assert.IsTrue (assemblyFound, "Failed to invoke the AssemblyResolve handler")
+ Assert.True (assemblyFound, "Failed to invoke the AssemblyResolve handler")
// Here the dispose was invoked which should clear the ResolvingUnmanagedDll handler
assemblyFound <- false
try Assembly.Load("NoneSuchAssembly") |> ignore with _ -> ()
- Assert.IsFalse (assemblyFound, "Invoke the assemblyProbingRoots callback -- Error the AssemblyResolve still fired ")
+ Assert.False (assemblyFound, "Invoke the assemblyProbingRoots callback -- Error the AssemblyResolve still fired ")
- []
+ []
member __.``Verify that #help produces help text for fsi + dependency manager``() =
let expected = [|
""" F# Interactive directives:"""
@@ -685,7 +685,7 @@ x |> Seq.iter(fun r ->
Assert.True(sawExpectedOutput.WaitOne(TimeSpan.FromSeconds(5.0)), sprintf "Expected to see error sentinel value written\nexpected:%A\nactual:%A" expected lines)
- []
+ []
member __.``Verify that #help produces help text for fsi + dependency manager language version preview``() =
let expected = [|
""" F# Interactive directives:"""
diff --git a/tests/FSharp.Compiler.Private.Scripting.UnitTests/DependencyManagerLineParserTests.fs b/tests/FSharp.Compiler.Private.Scripting.UnitTests/DependencyManagerLineParserTests.fs
index 98377faa09b..7f053975a76 100644
--- a/tests/FSharp.Compiler.Private.Scripting.UnitTests/DependencyManagerLineParserTests.fs
+++ b/tests/FSharp.Compiler.Private.Scripting.UnitTests/DependencyManagerLineParserTests.fs
@@ -4,9 +4,9 @@ namespace FSharp.DependencyManager.UnitTests
open System.Linq
open FSharp.DependencyManager.Nuget
-open NUnit.Framework
-[]
+open Xunit
+
type DependencyManagerLineParserTests() =
let parseBinLogPath text =
@@ -17,98 +17,98 @@ type DependencyManagerLineParserTests() =
let packageReferences, _ = FSharpDependencyManager.parsePackageReference ".fsx" [text]
packageReferences.Single()
- []
+ []
member __.``Binary logging defaults to disabled``() =
let _, binLogPath = FSharpDependencyManager.parsePackageReference ".fsx" []
- Assert.AreEqual(None, binLogPath)
+ Assert.Equal(None, binLogPath)
- []
+ []
member __.``Binary logging can be set to default path``() =
let binLogPath = parseBinLogPath "bl=true"
- Assert.AreEqual(Some (None: string option), binLogPath)
+ Assert.Equal(Some (None: string option), binLogPath)
- []
+ []
member __.``Binary logging can be disabled``() =
let binLogPath = parseBinLogPath "bl=false"
- Assert.AreEqual(None, binLogPath)
+ Assert.Equal(None, binLogPath)
- []
+ []
member __.``Binary logging can be set to specific location``() =
let binLogPath = parseBinLogPath "bl=path/to/file.binlog"
- Assert.AreEqual(Some(Some "path/to/file.binlog"), binLogPath)
+ Assert.Equal(Some(Some "path/to/file.binlog"), binLogPath)
- []
+ []
member __.``Bare binary log argument isn't parsed as a package name: before``() =
let packageReferences, binLogPath = FSharpDependencyManager.parsePackageReference ".fsx" ["bl, MyPackage"]
- Assert.AreEqual("MyPackage", packageReferences.Single().Include)
- Assert.AreEqual(Some (None: string option), binLogPath)
+ Assert.Equal("MyPackage", packageReferences.Single().Include)
+ Assert.Equal(Some (None: string option), binLogPath)
- []
+ []
member __.``Bare binary log argument isn't parsed as a package name: middle``() =
let packageReferences, binLogPath = FSharpDependencyManager.parsePackageReference ".fsx" ["MyPackage, bl, 1.2.3.4"]
- Assert.AreEqual("MyPackage", packageReferences.Single().Include)
- Assert.AreEqual("1.2.3.4", packageReferences.Single().Version)
- Assert.AreEqual(Some (None: string option), binLogPath)
+ Assert.Equal("MyPackage", packageReferences.Single().Include)
+ Assert.Equal("1.2.3.4", packageReferences.Single().Version)
+ Assert.Equal(Some (None: string option), binLogPath)
- []
+ []
member __.``Bare binary log argument isn't parsed as a package name: after``() =
let packageReferences, binLogPath = FSharpDependencyManager.parsePackageReference ".fsx" ["MyPackage, bl"]
- Assert.AreEqual("MyPackage", packageReferences.Single().Include)
- Assert.AreEqual(Some (None: string option), binLogPath)
+ Assert.Equal("MyPackage", packageReferences.Single().Include)
+ Assert.Equal(Some (None: string option), binLogPath)
- []
+ []
member __.``Package named 'bl' can be explicitly referenced``() =
let packageReferences, binLogPath = FSharpDependencyManager.parsePackageReference ".fsx" ["Include=bl"]
- Assert.AreEqual("bl", packageReferences.Single().Include)
- Assert.AreEqual(None, binLogPath)
+ Assert.Equal("bl", packageReferences.Single().Include)
+ Assert.Equal(None, binLogPath)
- []
+ []
member __.``Package named 'bl' can be explicitly referenced with binary logging``() =
let packageReferences, binLogPath = FSharpDependencyManager.parsePackageReference ".fsx" ["Include=bl,bl"]
- Assert.AreEqual("bl", packageReferences.Single().Include)
- Assert.AreEqual(Some (None: string option), binLogPath)
+ Assert.Equal("bl", packageReferences.Single().Include)
+ Assert.Equal(Some (None: string option), binLogPath)
- []
+ []
member __.``Parse explicitly specified package name``() =
let pr = parseSingleReference "Include=MyPackage"
- Assert.AreEqual("MyPackage", pr.Include)
+ Assert.Equal("MyPackage", pr.Include)
- []
+ []
member __.``Parse implicitly specified package name``() =
let pr = parseSingleReference "MyPackage"
- Assert.AreEqual("MyPackage", pr.Include)
+ Assert.Equal("MyPackage", pr.Include)
- []
+ []
member __.``Parse version number``() =
let pr = parseSingleReference "MyPackage, Version=1.2.3.4"
- Assert.AreEqual("1.2.3.4", pr.Version)
+ Assert.Equal("1.2.3.4", pr.Version)
- []
+ []
member __.``Parse implicitly specified package name and implicitly specified version number``() =
let pr = parseSingleReference "MyPackage, 1.2.3.4"
- Assert.AreEqual("MyPackage", pr.Include)
- Assert.AreEqual("1.2.3.4", pr.Version)
+ Assert.Equal("MyPackage", pr.Include)
+ Assert.Equal("1.2.3.4", pr.Version)
- []
+ []
member __.``Parse single restore source``() =
let pr = parseSingleReference "MyPackage, RestoreSources=MyRestoreSource"
- Assert.AreEqual("MyRestoreSource", pr.RestoreSources)
+ Assert.Equal("MyRestoreSource", pr.RestoreSources)
- []
+ []
member __.``Parse multiple restore sources``() =
let pr = parseSingleReference "MyPackage, RestoreSources=MyRestoreSource1, RestoreSources=MyRestoreSource2"
- Assert.AreEqual("MyRestoreSource1;MyRestoreSource2", pr.RestoreSources)
+ Assert.Equal("MyRestoreSource1;MyRestoreSource2", pr.RestoreSources)
- []
+ []
member __.``Parse script``() =
let pr = parseSingleReference "MyPackage, Script=SomeScript"
- Assert.AreEqual("SomeScript", pr.Script)
+ Assert.Equal("SomeScript", pr.Script)
- []
+ []
member __.``Include strings that look different but parse the same are reduced to a single item``() =
let prs, _ =
[ "MyPackage, Version=1.2.3.4"
"Include=MyPackage, Version=1.2.3.4" ]
|> FSharpDependencyManager.parsePackageReference ".fsx"
let pr = prs.Single()
- Assert.AreEqual("MyPackage", pr.Include)
+ Assert.Equal("MyPackage", pr.Include)
diff --git a/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharp.Compiler.Private.Scripting.UnitTests.fsproj b/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharp.Compiler.Private.Scripting.UnitTests.fsproj
index f7213d78671..2c159142462 100644
--- a/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharp.Compiler.Private.Scripting.UnitTests.fsproj
+++ b/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharp.Compiler.Private.Scripting.UnitTests.fsproj
@@ -6,7 +6,7 @@
netcoreapp3.1
Library
true
- nunit
+ xunit
true
@@ -16,10 +16,14 @@
-
+
+
+
+
+
diff --git a/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharpScriptTests.fs b/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharpScriptTests.fs
index a437b95283d..2c7be153960 100644
--- a/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharpScriptTests.fs
+++ b/tests/FSharp.Compiler.Private.Scripting.UnitTests/FSharpScriptTests.fs
@@ -11,38 +11,38 @@ open System.Threading
open System.Threading.Tasks
open FSharp.Compiler.Interactive.Shell
open FSharp.Compiler.Scripting
-open NUnit.Framework
-[]
+open Xunit
+
type InteractiveTests() =
- []
+ []
member __.``Eval object value``() =
use script = new FSharpScript()
let opt = script.Eval("1+1") |> getValue
let value = opt.Value
- Assert.AreEqual(typeof, value.ReflectionType)
- Assert.AreEqual(2, value.ReflectionValue :?> int)
+ Assert.Equal(typeof, value.ReflectionType)
+ Assert.Equal(2, value.ReflectionValue :?> int)
- []
+ []
member __.``Declare and eval object value``() =
use script = new FSharpScript()
let opt = script.Eval("let x = 1 + 2\r\nx") |> getValue
let value = opt.Value
- Assert.AreEqual(typeof, value.ReflectionType)
- Assert.AreEqual(3, value.ReflectionValue :?> int)
+ Assert.Equal(typeof, value.ReflectionType)
+ Assert.Equal(3, value.ReflectionValue :?> int)
- []
+ []
member __.``Capture console input``() =
use input = new RedirectConsoleInput()
use script = new FSharpScript()
input.ProvideInput "stdin:1234\r\n"
let opt = script.Eval("System.Console.ReadLine()") |> getValue
let value = opt.Value
- Assert.AreEqual(typeof, value.ReflectionType)
- Assert.AreEqual("stdin:1234", value.ReflectionValue)
+ Assert.Equal(typeof, value.ReflectionType)
+ Assert.Equal("stdin:1234", downcast value.ReflectionValue)
- []
+ []
member __.``Capture console output/error``() =
use output = new RedirectConsoleOutput()
use script = new FSharpScript()
@@ -54,16 +54,16 @@ type InteractiveTests() =
Assert.True(sawOutputSentinel.WaitOne(TimeSpan.FromSeconds(5.0)), "Expected to see output sentinel value written")
Assert.True(sawErrorSentinel.WaitOne(TimeSpan.FromSeconds(5.0)), "Expected to see error sentinel value written")
- []
+ []
member __.``Maintain state between submissions``() =
use script = new FSharpScript()
script.Eval("let add x y = x + y") |> ignoreValue
let opt = script.Eval("add 2 3") |> getValue
let value = opt.Value
- Assert.AreEqual(typeof, value.ReflectionType)
- Assert.AreEqual(5, value.ReflectionValue :?> int)
+ Assert.Equal(typeof, value.ReflectionType)
+ Assert.Equal(5, downcast value.ReflectionValue)
- []
+ []
member __.``Assembly reference event successful``() =
use script = new FSharpScript()
let testCode = """
@@ -73,53 +73,53 @@ stacktype.Name = "Stack"
"""
let opt = script.Eval(testCode) |> getValue
let value = opt.Value
- Assert.AreEqual(true, value.ReflectionValue :?> bool)
+ Assert.Equal(true, downcast value.ReflectionValue)
- []
+ []
member __.``Assembly reference unsuccessful``() =
use script = new FSharpScript()
let testAssembly = "not-an-assembly-that-can-be-found.dll"
let _result, errors = script.Eval(sprintf "#r \"%s\"" testAssembly)
- Assert.AreEqual(1, errors.Length)
+ Assert.Equal(1, errors.Length)
- []
+ []
member _.``Compilation errors report a specific exception``() =
use script = new FSharpScript()
let result, _errors = script.Eval("abc")
match result with
- | Ok(_) -> Assert.Fail("expected a failure")
- | Error(ex) -> Assert.IsInstanceOf(ex)
+ | Ok(_) -> Assert.False(true, "expected a failure")
+ | Error(ex) -> Assert.IsAssignableFrom(typeof, ex)
- []
+ []
member _.``Runtime exceptions are propagated``() =
use script = new FSharpScript()
let result, errors = script.Eval("System.IO.File.ReadAllText(\"not-a-file-path-that-can-be-found-on-disk.txt\")")
- Assert.IsEmpty(errors)
+ Assert.Empty(errors)
match result with
- | Ok(_) -> Assert.Fail("expected a failure")
- | Error(ex) -> Assert.IsInstanceOf(ex)
+ | Ok(_) -> Assert.True(false, "expected a failure")
+ | Error(ex) -> Assert.IsAssignableFrom(typeof, ex)
- []
+ []
member _.``Script with #r "" errors``() =
use script = new FSharpScript()
let result, errors = script.Eval("#r \"\"")
- Assert.IsNotEmpty(errors)
+ Assert.NotEmpty(errors)
match result with
- | Ok(_) -> Assert.Fail("expected a failure")
- | Error(ex) -> Assert.IsInstanceOf(ex)
+ | Ok(_) -> Assert.False(true, "expected a failure")
+ | Error(ex) -> Assert.IsAssignableFrom(typeof, ex)
- []
+ []
member _.``Script with #r " " errors``() =
use script = new FSharpScript()
let result, errors = script.Eval("#r \" \"")
- Assert.IsNotEmpty(errors)
+ Assert.NotEmpty(errors)
match result with
- | Ok(_) -> Assert.Fail("expected a failure")
- | Error(ex) -> Assert.IsInstanceOf(ex)
+ | Ok(_) -> Assert.False(true, "expected a failure")
+ | Error(ex) -> Assert.IsAssignableFrom(typeof, ex)
/// Native dll resolution is not implemented on desktop
#if NETSTANDARD
- []
+ []
member __.``ML - use assembly with native dependencies``() =
let code = @"
#r ""nuget:RestoreSources=https://dotnet.myget.org/F/dotnet-corefxlab/api/v3/index.json""
@@ -163,18 +163,18 @@ printfn ""%A"" result
use script = new FSharpScript(additionalArgs=[|"/langversion:preview"|])
let opt = script.Eval(code) |> getValue
let value = opt.Value
- Assert.AreEqual(123, value.ReflectionValue :?> int32)
+ Assert.Equal(123, value.ReflectionValue :?> int32)
#endif
- []
+ []
member __.``Eval script with package manager invalid key``() =
use script = new FSharpScript(additionalArgs=[|"/langversion:preview"|])
let result, _errors = script.Eval(@"#r ""nugt:FSharp.Data""")
match result with
- | Ok(_) -> Assert.Fail("expected a failure")
- | Error(ex) -> Assert.IsInstanceOf(ex)
+ | Ok(_) -> Assert.False(true, "expected a failure")
+ | Error(ex) -> Assert.IsAssignableFrom(typeof, ex)
- []
+ [