anchor.diff:      let openPath _ _ _ = failwith "openPath should not be called"
       let newName = newNodes.[1].Name
       let model = createModel()
  -    model.Cursor <- 1
       MainLogic.Action.rename move openPath oldNodes.[1] newName model
   
       let expectedAction = RenamedItem (oldNodes.[1], newNodes.[1].Name)
       let expected = createModel()
  -    expected.Cursor <- 1
       expected |> MainStatus.setActionExceptionStatus expectedAction ex
       assertAreEqual expected model
   
  
positive.code:     expected.RedoStack <- []
      expected.Status <- Some <| MainStatus.actionComplete expectedAction model.PathFormat
      assertAreEqual expected model
  
  [<Test>]
  let ``Create folder sets error status when item already exists at path``() =
      let existing = oldNodes.[1]
      let getNode _ = Some existing
      let create _ _ = failwith "create should not be called"
      let openPath p select (model: MainModel) =
          model.Path <- p
          if select = SelectName existing.Name then
              model.Cursor <- 1
      let createNode = newNodes.[1]
      let model = createModel()
      MainLogic.Action.create getNode create openPath Folder createNode.Name model
  
      let expected = createModel()
      expected.Cursor <- 1
      expected.Status <- Some <| MainStatus.cannotCreateAlreadyExists Folder createNode.Name
      assertAreEqual expected model
  
  [<Test>]
  let ``Create folder handles error by setting error status``() =
  
negative.code:     let getNode _ = None
      let mutable created = None
      let create nodeType path = created <- Some (nodeType, path)
      let mutable selected = None
      let openPath p s (model: MainModel) =
          model.Path <- p
          model.Nodes <- newNodes
          model.Cursor <- 1
          selected <- Some s
      let createNode = newNodes.[1]
      let model = createModel()
      MainLogic.Action.create getNode create openPath Folder createNode.Name model
  