anchor.diff:      let runCts (workflow : DistributedCancellationTokenSource -> Cloud<'T>) = 
           async {
               let runtime = Option.get runtime
  -            let! dcts = DistributedCancellationTokenSource.Create(config, testContainer) 
  +            let! dcts = DistributedCancellationTokenSource.Create(configId, testContainer) 
               let ct = dcts.GetLocalCancellationToken()
               let ps = runtime.CreateProcess(workflow dcts, cancellationToken = ct) 
               processes.Add(ps)
               return! ps.AwaitResultAsync() |> Async.Catch 
           } |> Async.RunSync
       
  +    member __.Configuration = config
  +
  +    abstract Init : unit -> unit
       [<TestFixtureSetUp>]
  -    member __.Init () =
  -        let cfg = 
  -            { Configuration.Default with
  -                StorageConnectionString = Utils.selectEnv "azurestorageconn"
  -                ServiceBusConnectionString = Utils.selectEnv "azureservicebusconn" }
  -
  -        let print (s : string) = if s = null then "<null>" else sprintf "%s . . ." <| s.Substring(0,15)
  -        printfn "config.Storage : %s" <| print cfg.StorageConnectionString
  -        printfn "config.ServiceBus : %s" <| print cfg.ServiceBusConnectionString
  -        Runtime.WorkerExecutable <- __SOURCE_DIRECTORY__ + "/../../bin/MBrace.Azure.Runtime.Standalone.exe"
  -        printfn "WorkerExecutable : %s" Runtime.WorkerExecutable
  -        runtime <- Some <| Runtime.InitLocal(cfg, 4, 16)
  -        config <- cfg.ConfigurationId
  -        printfn "Runtime initialized"
  +    default __.Init () =
  +        runtime <- Some <| MBrace.Azure.Client.Runtime.GetHandle(config)
  +        printfn "Got Handle for runtime"
           runtime.Value.ClientLogger.Attach(new MBrace.Azure.Runtime.Common.ConsoleLogger()) 
   
       [<TestFixtureTearDown>]
  
positive.code: 
      [<Test>]
      member __.``1. Parallel : use binding`` () =
          let counter = Counter.Create(config, testContainer, 0) |> Async.RunSync
          cloud {
              use foo = { new ICloudDisposable with member __.Dispose () = async { return counter.Incr() |> ignore } }
              let! _ = cloud { return counter.Incr() } <||> cloud { return counter.Incr() }
  
negative.code: 
      [<Test>]
      member __.``1. Parallel : finally`` () =
          let counter = Counter.Create(configId, testContainer, 0) |> Async.RunSync
          cloud {
              try
                  let! x,y = cloud { return 1 } <||> cloud { return invalidOp "failure" }
  