anchor.diff:    String get path => file.path;
   
     @override
  -  Future delete() {
  -    return file.exists().then((exists) {
  -      return file.delete(recursive: true).catchError((_) {});
  -    });
  +  Future delete() async {
  +    if (await file.exists()) {
  +      try {
  +        await file.delete(recursive: true);
  +      } catch (_) {}
  +    }
     }
   
     @override
  
positive.code:   }
  
    @override
    Future findOrCreate() {
      return fs.isFile(path).then((isFile) {
        if (!isFile) {
          // try to recover from tmp file
          return new Future.sync(() {
            if (isTmp == true) {
              return false;
            } else {
              return tmpRecover();
            }
          }).then((bool done) {
            if (!done) {
              return file
                  .create(recursive: true)
                  .then((File file) {})
                  .catchError((e) {
                return fs.isFile(path).then((isFile) {
                  if (!isFile) {
                    throw e;
                  }
                });
              });
            } else {
              // ok found fine
            }
          });
        }
      });
    }
  
    String get tmpPath => join(dirname(path), "~${basename(path)}");
  
negative.code:     return new _FsDatabaseStorage(fs, tmpPath)..isTmp = true;
    }
  
  
    @override
    Future<bool> tmpRecover() async {
      bool isFile = await fs.isFile(tmpPath);
      log.info("Recovering from ${tmpPath}");
  
      if (isFile) {
        try {
          await file.delete();
        } catch (e) {
          print('fail to delete');
          print(e);
          //return true;
        }
        await fs.newFile(tmpPath).rename(file.path);
  
        // ok
        return true;
      } else {
        return false;
      }
    }
  
    Stream<String> readLines() {
  