readFile: function readFile(file: any, options: any, callback: any) {
      setupManifest()
      const entry = manifest[file]
      if (!entry || !isString(file)) {
        return originalReadFile.apply(fs, arguments)
      }
      const [offset, length] = entry
      const resourceOffset = resourceStart + offset
      const encoding = isString(options) ? options : null
      callback = typeof options === 'function' ? options : callback

      fs.open(process.execPath, 'r', function(err: Error, fd: number) {
        if (err) return callback(err, null)
        fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function(
          error: Error,
          bytesRead: number,
          result: Buffer
        ) {
          if (error) {
            return fs.close(fd, function() {
              callback(error, null)
            })
          }
          fs.close(fd, function(err: Error) {
            if (err) {
              return callback(err, result)
            }
            callback(err, encoding ? result.toString(encoding) : result)
          })
        })
      })
    },

	args.map(function(path, i): void {
		// '-' represents stdin, which is already open.
		// Special-case it.
		if (path === '-') {
			files[i] = process.stdin;
			// if we've opened all of the files, pipe them
			// to stdout.
			opened();
			return;
		}
		fs.open(path, 'r', function(err: any, fd: any): void {
			if (err) {
				// if we couldn't open the specified
				// file we should print a message but
				// not exit early - we need to process
				// as many inputs as we can.
				files[i] = null;
				code = 1;
				let msg = pathToScript + ': ' + err.message + '\n';
				process.stderr.write(msg, opened);
				return;
			}
			files[i] = fs.createReadStream(path, {fd: fd});
			opened();
		});
	});

		return new Promise<string>((resolve, reject) => {
			const dir = path.join('..', 'Projects', 'Repository');
			const parenthash = id;

			if (Project.checkFilename(filename)) {
				Project.error(socket, 'Bad filename.');
				return parenthash;
			}

			git.readTreeEmpty(dir);
			git.readTree(dir, parenthash);

			fs.open(path.join('..', 'Projects', 'Temp', 'whatever'), 'w', (err, fd) => {
				if (err) {
					throw 'Error opening file: ' + err;
				}
			
				fs.write(fd, buffer, 0, buffer.length, null, (err) => {
					if (err) throw 'Error writing file: ' + err;
					fs.close(fd, async () => {
						const objecthash = git.hashObject(dir, path.join('..', 'Temp', 'whatever'));
						git.addToIndex(dir, objecthash, 'Assets/' + filename);
						const treehash = git.writeTree(dir);
						const sha = git.commitTree(dir, treehash, parenthash);
						resolve(sha);
					});
				});
			});
		});

    it('should read', async function (done) {
        this.timeout(1000000);

        try {
            let filePath = "/Users/epi/Projects/santelab/santelab_dane_2016_05_03/WYNIKI.dbt";
            fs.open(filePath, 'r', async function (rs) {
                console.log('opnd')
                let reader = new DbtReader(rs, '852');
                console.log('opnd2')
                // let parser = new Parser(rs, '852');

                let h = await reader.parseHeader();
                console.log('HHHH')
                console.log(h);
                for (let i = 0; i < 10; i++) {
                    let b = await reader.readBlock(i, h);
                    console.log(b);
                }
            });


        } catch (error) {
            done(error);
        }
    });

			fs.stat(path, function(err: any, stats: fs.Stats): void {
				if (err) {
					// if we couldn't stat the
					// specified file we should
					// create it.  Pass 'x' for
					// the CREAT flag.
					fs.open(path, 'wx', function(oerr:  any, fd: number): void {
						if (oerr) {
							// now we're in trouble and
							// we should try other files instead.
							code = 1;
							let msg = pathToScript + ': ' + oerr + '\n';
							process.stderr.write(msg, finished);
						}
						// thats it - close the sucker.
						fs.close(fd, finished);
					});
				} else {
					// file exists - just use utimes,
					// no need to open it.
					fs.utimes(path, now, now, (uerr: any) => {
						if (uerr) {
							code = 1;
							process.stderr.write('utimes: ' + uerr.message + '\n', finished);
							return;
						}
						finished();
					});
				}
			});

	protected readQueryFile(queryFile: string): Q.Promise<any> {
		let deferred = Q.defer<any>();

		// check if the query file exists
		fs.open(queryFile, "r", function(err, fd) {
			if(err) {
				deferred.reject(err);
			} else {
				fs.readFile(queryFile, {encoding: 'utf-8'}, function(err, query) {
					if(err) {
						deferred.reject(err);
					} else {
						// check if we got a valid query json file
						try {
							let queryJSON: JSONQuery = JSON.parse(query);

							deferred.resolve(queryJSON);
						} catch(err) {
							deferred.reject('ERROR: Could not parse query JSON file. Error = '+err);
						};

					}
				});
			}
		});

		return deferred.promise;
	}

		new Promise((resolve, reject) => {

			// Create a file with a name of the form 'file._id.<ext>', where <ext> is the extension of the original file
			var filepath = __dirname + '/../' + file._id + '.' + file.filename.substr(file.filename.lastIndexOf('.') + 1);

			// Check whether the file already exists
			fs.open(filepath, 'r', (err: Error, fd: any) => {
				if (!err) {
					// File already exits
					fs.closeSync(fd);
					resolve(null);
				}
				else {
					// File does not exist...create it
					var fs_write_stream = fs.createWriteStream(filepath);

					var gfs = Grid(conn.db);

					// Read from mongodb
					var readstream = gfs.createReadStream({ _id: file._id });
					readstream.pipe(fs_write_stream);
					fs_write_stream.on('close', () => {
						resolve(null);
					});
					fs_write_stream.on('error', () => {
						err = Error('file creation error: ' + filepath);
						reject(err);
					});
				}
			});
		});

		args.map(function(path: string, i: number): void {
			if (path === '-') {
				files[i] = process.stdin;
				// if we've opened all of the files, pipe them to
				// stdout.
				if (++opened === args.length)
					setTimeout(concat, 0, files, process.stdout, code);
				return;
			}
			fs.open(path, 'r', function(err: any, fd: any): void {
				if (err) {
					// if we couldn't open the
					// specified file we should
					// print a message but not
					// exit early - we need to
					// process as many inputs as
					// we can.
					files[i] = null;
					code = 1;
					log(err.message);
				} else {
					files[i] = fs.createReadStream(path, {fd: fd});
				}
				// if we've opened all of the files,
				// pipe them to stdout.
				if (++opened === args.length)
					setTimeout(concat, 0, files, process.stdout, code);
			});
		});

 return new Promise<any>((resolve, reject) => {
     fs.open(filePath, "r", (err: any, fd: any) => {
         if (err) {
             reject(err);
         } else {
             resolve(fd);
         }
     });
 });

 private useFile(file: string) {
     this.queue = [];
     this.queueFlushable = false;
     fs.open(file, "a+", 0o666, (err, fd: number) => {
         this.fd = fd;
         this.queueFlushable = true;
         this.writeQueue();
     });
 }