anchor.diff:  [<Test>]
   let ``should filter _._ when processing blacklist``() = 
       let model = 
  -        [ @"..\Rx-Main\lib\net40\_._"; @"..\Rx-Main\lib\net20\_._" ] 
  -        |> extractFrameworksFromPaths InstallModell.EmptyModel
  -        |> filterBlackList
  +        InstallModell.FromLibs([ @"..\Rx-Main\lib\net40\_._"; @"..\Rx-Main\lib\net20\_._" ])
  +            .FilterBlackList()
   
       model.GetFiles(DotNetFramework(Framework "v2.0", Full)) |> shouldNotContain @"..\Rx-Main\lib\net20\_._"
       model.GetFiles(DotNetFramework(Framework "v4.0", Full)) |> shouldNotContain @"..\Rx-Main\lib\net40\_._"
  
positive.code: [<Test>]
  let ``should skip lib install of Microsoft.BCL for monotouch and monoandroid``() = 
      let model = 
          [ @"..\Microsoft.Bcl\lib\net40\System.IO.dll" 
            @"..\Microsoft.Bcl\lib\net40\System.Runtime.dll" 
            @"..\Microsoft.Bcl\lib\net40\System.Threading.Tasks.dll" 
            @"..\Microsoft.Bcl\lib\monoandroid\_._" 
            @"..\Microsoft.Bcl\lib\monotouch\_._" 
            @"..\Microsoft.Bcl\lib\net45\_._" 
          ]
          |> extractFrameworksFromPaths InstallModell.EmptyModel
          |> useLowerVersionLibIfEmpty
          |> filterBlackList
  
      model.GetFiles(MonoAndroid) |> shouldBeEmpty
      model.GetFiles(MonoTouch) |> shouldBeEmpty
  
negative.code:     member this.GetFrameworks() = this.Frameworks |> Seq.map (fun kv -> kv.Key)
      member this.GetFiles(framework) = this.Frameworks.[framework]
  
      member this.Add(framework,lib) : InstallModell = 
          { this with Frameworks = 
                       match Map.tryFind framework this.Frameworks with
                       | Some files -> Map.add framework (Set.add lib files) this.Frameworks
                       | None -> Map.add framework (Set.singleton lib) this.Frameworks }
  
      member this.Add (libs) : InstallModell = 
          libs |> List.fold (fun model lib -> 
                      match FrameworkIdentifier.DetectFromPathNew lib with
                      | Some framework -> model.Add(framework,lib)
                      | _ -> model) this
  
  
      member this.FilterBlackList() =
          { this with Frameworks = 
                       blackList 
                       |> List.fold 
                              (fun frameworks f -> Map.map (fun _ files -> files |> Set.filter (f >> not)) frameworks) 
                          this.Frameworks }
  
      member this.UseLowerVersionLibIfEmpty() = 
          KnownDotNetFrameworks
          |> List.rev
          |> List.fold (fun (model : InstallModell) (lowerVersion,lowerProfile) -> 
                 let newFiles = model.GetFiles(DotNetFramework(Framework lowerVersion, lowerProfile))
                 if Set.isEmpty newFiles then model
                 else 
                     KnownDotNetFrameworks
                     |> List.filter (fun (version,profile) -> (version,profile) > (lowerVersion,lowerProfile))
                     |> List.fold (fun (model : InstallModell) (upperVersion,upperProfile) -> 
                            let framework = DotNetFramework(Framework upperVersion, upperProfile)
                            match Map.tryFind framework model.Frameworks with
                            | Some files when Set.isEmpty files -> 
                                { model with Frameworks = Map.add framework newFiles model.Frameworks }
                            | _ -> model) model) this
  
      member this.UsePortableVersionLibIfEmpty() = 
          this.Frameworks 
          |> Seq.fold 
                 (fun (model : InstallModell) kv -> 
                 let newFiles = kv.Value
             
                 let otherProfiles = 
                     match kv.Key with
                     | PortableFramework(_, f) -> 
                         f.Split([| '+' |], System.StringSplitOptions.RemoveEmptyEntries)
                         |> Array.map (FrameworkIdentifier.Extract false)
                         |> Array.choose id
                     | _ -> [||]
                 if Set.isEmpty newFiles || Array.isEmpty otherProfiles then model
                 else 
                     otherProfiles 
                     |> Array.fold (fun (model : InstallModell) framework -> 
                            match Map.tryFind framework model.Frameworks with
                            | Some files when Set.isEmpty files |> not -> model
                            | _ -> { model with Frameworks = Map.add framework newFiles model.Frameworks }) model) this
  
      static member FromLibs libs = InstallModell.EmptyModel.Add libs
  
  [<Test>]
  let ``should create empty model with net40, net45 ...``() = 
      let model = InstallModell.FromLibs [ @"..\Rx-Main\lib\net40\Rx.dll"; @"..\Rx-Main\lib\net45\Rx.dll" ] 
  
      model.GetFrameworks() |> shouldContain (DotNetFramework(Framework "v4.0", Full))
      model.GetFrameworks() |> shouldContain (DotNetFramework(Framework "v4.5", Full))
  
  [<Test>]
  let ``should understand net40 and net45``() = 
      let model = InstallModell.FromLibs [ @"..\Rx-Main\lib\net40\Rx.dll"; @"..\Rx-Main\lib\net45\Rx.dll" ] 
  
      model.GetFiles(DotNetFramework(Framework "v4.0", Full)) |> shouldContain @"..\Rx-Main\lib\net40\Rx.dll"
      model.GetFiles(DotNetFramework(Framework "v4.5", Full)) |> shouldContain @"..\Rx-Main\lib\net45\Rx.dll"
  
  [<Test>]
  let ``should add net35 if we have net20 and net40``() = 
      let model = 
          InstallModell.FromLibs([ @"..\Rx-Main\lib\net20\Rx.dll"; @"..\Rx-Main\lib\net40\Rx.dll" ])
              .UseLowerVersionLibIfEmpty()
  
      model.GetFiles(DotNetFramework(Framework "v2.0", Full)) |> shouldContain @"..\Rx-Main\lib\net20\Rx.dll"
      model.GetFiles(DotNetFramework(Framework "v3.5", Full)) |> shouldContain @"..\Rx-Main\lib\net20\Rx.dll"
  