// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'dart:async';
import 'dart:typed_data';

import 'package:fidl/fidl.dart';
import 'package:fidl_fuchsia_io/fidl_async.dart';
import 'package:fuchsia_vfs/vfs.dart';
import 'package:test/test.dart';
import 'package:zircon/zircon.dart';

void main() {
  const _newStr = 'new_str';
  final _newStrList = Uint8List.fromList(_newStr.codeUnits);

  InterfaceRequest<Node> _getNodeInterfaceRequest(FileProxy proxy) {
    return InterfaceRequest<Node>(proxy.ctrl.request().passChannel());
  }

  _ReadOnlyFile _createReadOnlyFile(String str, OpenFlags openFlags,
      [int expectedStatus = ZX.OK]) {
    _ReadOnlyFile file = _ReadOnlyFile()
      ..pseudoFile = PseudoFile.readOnlyStr(() {
        return str;
      })
      ..proxy = FileProxy();
    expect(
        file.pseudoFile
            .connect(openFlags, 0, _getNodeInterfaceRequest(file.proxy)),
        expectedStatus);
    return file;
  }

  Future<void> _assertFinalBuffer(FileProxy proxy, _ReadWriteFile file,
      String oldStr, String newStr) async {
    // our buffer should contain old string
    expect(file.buffer, oldStr);

    await proxy.close();

    // our buffer should contain new string
    expect(file.buffer, newStr);
  }

  Future<void> _assertWrite(FileProxy proxy, Uint8List content,
      {int expectedStatus = ZX.OK, int? expectedSize}) async {
    expectedSize ??= content.length;
    if (expectedStatus == ZX.OK) {
      final actualCount = await proxy.write(content);
      expect(actualCount, expectedSize);
    } else {
      await expectLater(
          proxy.write(content),
          throwsA(isA<MethodException>()
              .having((e) => e.value, 'value', equals(expectedStatus))));
    }
  }

  Future<void> _assertRead(FileProxy proxy, int bufSize, String expectedStr,
      {expectedStatus = ZX.OK}) async {
    if (expectedStatus == ZX.OK) {
      final data = await proxy.read(bufSize);
      expect(String.fromCharCodes(data), expectedStr);
    } else {
      await expectLater(
          proxy.read(bufSize),
          throwsA(isA<MethodException>()
              .having((e) => e.value, 'value', equals(expectedStatus))));
    }
  }

  Future<void> _assertReadAt(
      FileProxy proxy, int bufSize, int offset, String expectedStr,
      {expectedStatus = ZX.OK}) async {
    if (expectedStatus == ZX.OK) {
      final data = await proxy.readAt(bufSize, offset);
      expect(String.fromCharCodes(data), expectedStr);
    } else {
      await expectLater(
          proxy.readAt(bufSize, offset),
          throwsA(isA<MethodException>()
              .having((e) => e.value, 'value', equals(expectedStatus))));
    }
  }

  Future<void> _assertWriteAt(
      FileProxy proxy, Uint8List content, int offset, int expectedWrittenLen,
      {expectedStatus = ZX.OK}) async {
    if (expectedStatus == ZX.OK) {
      final actualCount = await proxy.writeAt(content, offset);
      expect(actualCount, expectedWrittenLen);
    } else {
      await expectLater(
          proxy.writeAt(content, offset),
          throwsA(isA<MethodException>()
              .having((e) => e.value, 'value', equals(expectedStatus))));
    }
  }

  group('pseudo file creation validation: ', () {
    PseudoFile _createReadWriteFileStub() {
      return PseudoFile.readWriteStr(1, () {
        return '';
      }, (String str) {
        return ZX.OK;
      });
    }

    final _notAllowedFlags = [
      OpenFlags.create,
      OpenFlags.createIfAbsent,
    ];

    test('onOpen event on flag validation error', () async {
      final file = _createReadOnlyFile('',
          OpenFlags.rightWritable | OpenFlags.describe, ZX.ERR_NOT_SUPPORTED);

      await file.proxy.onOpen.first.then((response) {
        expect(response.s, ZX.ERR_NOT_SUPPORTED);
        expect(response.info, isNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    test('read only file', () async {
      final file = _createReadOnlyFile(
          '', OpenFlags.rightWritable, ZX.ERR_NOT_SUPPORTED);

      {
        final proxy = FileProxy();
        expect(
            file.pseudoFile.connect(
                OpenFlags.truncate, 0, _getNodeInterfaceRequest(proxy)),
            ZX.ERR_NOT_SUPPORTED);
      }

      {
        final proxy = FileProxy();
        expect(
            file.pseudoFile.connect(
                OpenFlags.directory, 0, _getNodeInterfaceRequest(proxy)),
            ZX.ERR_NOT_DIR);
      }

      {
        final proxy = FileProxy();
        expect(
            file.pseudoFile
                .connect(OpenFlags.append, 0, _getNodeInterfaceRequest(proxy)),
            ZX.ERR_INVALID_ARGS);
      }

      for (final flag in _notAllowedFlags) {
        final proxy = FileProxy();
        expect(
            file.pseudoFile.connect(flag, 0, _getNodeInterfaceRequest(proxy)),
            ZX.ERR_NOT_SUPPORTED,
            reason: 'for flag: $flag');
      }
    });

    test('read write file', () async {
      final file = _createReadWriteFileStub();

      {
        final proxy = FileProxy();
        expect(
            file.connect(
                OpenFlags.directory, 0, _getNodeInterfaceRequest(proxy)),
            ZX.ERR_NOT_DIR);
      }

      {
        final proxy = FileProxy();
        expect(
            file.connect(OpenFlags.append, 0, _getNodeInterfaceRequest(proxy)),
            ZX.ERR_INVALID_ARGS);
      }

      for (final flag in _notAllowedFlags) {
        final proxy = FileProxy();
        expect(file.connect(flag, 0, _getNodeInterfaceRequest(proxy)),
            ZX.ERR_NOT_SUPPORTED,
            reason: 'for flag: $flag');
      }
    });

    test('connect file with mode', () async {
      final file = _createReadWriteFileStub();

      {
        final proxy = FileProxy();
        expect(
            file.connect(OpenFlags.rightReadable | OpenFlags.describe,
                ~modeTypeFile, _getNodeInterfaceRequest(proxy)),
            ZX.ERR_INVALID_ARGS);

        await proxy.onOpen.first.then((response) {
          expect(response.s, ZX.ERR_INVALID_ARGS);
          expect(response.info, isNull);
        }).catchError((err) async {
          fail(err.toString());
        });
      }

      {
        final proxy = FileProxy();
        expect(
            file.connect(OpenFlags.rightReadable | OpenFlags.describe,
                modeTypeFile, _getNodeInterfaceRequest(proxy)),
            ZX.OK);
        await proxy.onOpen.first.then((response) {
          expect(response.s, ZX.OK);
          expect(response.info, isNotNull);
        }).catchError((err) async {
          fail(err.toString());
        });
      }
    });

    test('open fails', () async {
      final file = _createReadWriteFileStub();

      final paths = ['', '/', '.', './', './/', './//'];
      for (final path in paths) {
        final proxy = FileProxy();
        file.open(OpenFlags.rightReadable | OpenFlags.describe, 0, path,
            _getNodeInterfaceRequest(proxy), OpenFlags.rightReadable);

        await proxy.onOpen.first.then((response) {
          expect(response.s, ZX.ERR_NOT_DIR);
          expect(response.info, isNull);
        }).catchError((err) async {
          fail(err.toString());
        });
      }
    });
  });

  group('pseudo file:', () {
    _ReadWriteFile _createReadWriteFile(String initialStr,
        {int? capacity, createProxy = true, OpenFlags? flags}) {
      int c = initialStr.length;
      if (capacity != null) {
        assert(capacity >= initialStr.length);
        c = capacity;
      }
      _ReadWriteFile file = _ReadWriteFile();
      file
        ..buffer = initialStr
        ..pseudoFile = PseudoFile.readWriteStr(c, () {
          return file.buffer;
        }, (String str) {
          file.buffer = str;
          return ZX.OK;
        });
      if (createProxy) {
        file.proxy = FileProxy();
        expect(
            file.pseudoFile.connect(
                flags ?? OpenFlags.rightReadable | OpenFlags.rightWritable,
                0,
                _getNodeInterfaceRequest(file.proxy)),
            ZX.OK);
      }
      return file;
    }

    test('onOpen event on success', () async {
      final file = _createReadOnlyFile(
          'test_str', OpenFlags.rightReadable | OpenFlags.describe);

      await file.proxy.onOpen.first.then((response) {
        expect(response.s, ZX.OK);
        expect(response.info, isNotNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    final expectedNodeAttrs = NodeAttributes(
        mode: modeTypeFile | modeProtectionMask,
        id: inoUnknown,
        contentSize: 0,
        storageSize: 0,
        linkCount: 1,
        creationTime: 0,
        modificationTime: 0);

    test('test getAttr', () async {
      final file = _createReadOnlyFile('test_str', OpenFlags.rightReadable);
      final response = await file.proxy.getAttr();
      expect(response.s, ZX.OK);
      expect(response.attributes, expectedNodeAttrs);
    });

    test('clone works', () async {
      final file = _createReadOnlyFile('test_str', OpenFlags.rightReadable);

      final clonedProxy = FileProxy();
      await file.proxy.clone(OpenFlags.rightReadable | OpenFlags.describe,
          _getNodeInterfaceRequest(clonedProxy));

      await clonedProxy.onOpen.first.then((response) {
        expect(response.s, ZX.OK);
        expect(response.info, isNotNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    test('clone works with POSIX compatibility flags', () async {
      final file = _createReadOnlyFile('test_str', OpenFlags.rightReadable);

      final clonedProxy = FileProxy();
      await file.proxy.clone(
          OpenFlags.rightReadable |
              OpenFlags.describe |
              OpenFlags.posixWritable |
              OpenFlags.posixExecutable,
          _getNodeInterfaceRequest(clonedProxy));

      await clonedProxy.onOpen.first.then((response) {
        expect(response.s, ZX.OK);
        expect(response.info, isNotNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    test('clone fails when trying to pass Readable flag to Node Reference',
        () async {
      final file = _createReadOnlyFile(
          'test_str', OpenFlags.rightReadable | OpenFlags.nodeReference);

      final clonedProxy = FileProxy();
      await file.proxy.clone(OpenFlags.rightReadable | OpenFlags.describe,
          _getNodeInterfaceRequest(clonedProxy));

      await clonedProxy.onOpen.first.then((response) {
        expect(response.s, ZX.ERR_ACCESS_DENIED);
        expect(response.info, isNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    test('clone fails when trying to pass Writable flag to Node Reference',
        () async {
      final file = _createReadWriteFile('test_str',
          flags: OpenFlags.rightWritable | OpenFlags.nodeReference);

      final clonedProxy = FileProxy();
      await file.proxy.clone(OpenFlags.rightWritable | OpenFlags.describe,
          _getNodeInterfaceRequest(clonedProxy));

      await clonedProxy.onOpen.first.then((response) {
        expect(response.s, ZX.ERR_ACCESS_DENIED);
        expect(response.info, isNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    test('able to clone Node Reference', () async {
      final file = _createReadOnlyFile('test_str', OpenFlags.nodeReference);

      final clonedProxy = FileProxy();
      await file.proxy.clone(OpenFlags.nodeReference | OpenFlags.describe,
          _getNodeInterfaceRequest(clonedProxy));

      await clonedProxy.onOpen.first.then((response) {
        expect(response.s, ZX.OK);
        expect(response.info, isNotNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    test('clone should fail if requested rights exceed source rights',
        () async {
      final file = _createReadWriteFile('test_str', createProxy: false);
      final flagsToTest = [OpenFlags.rightReadable, OpenFlags.rightWritable];

      for (final flag in flagsToTest) {
        final proxy = FileProxy();
        expect(
            file.pseudoFile
                .connect(OpenFlags.$none, 0, _getNodeInterfaceRequest(proxy)),
            ZX.OK);

        final clonedProxy = FileProxy();
        await proxy.clone(
            flag | OpenFlags.describe, _getNodeInterfaceRequest(clonedProxy));

        await clonedProxy.onOpen.first.then((response) {
          expect(response.s, ZX.ERR_ACCESS_DENIED);
          expect(response.info, isNull);
        }).catchError((err) async {
          fail(err.toString());
        });
      }
    });

    test('onOpen with describe flag', () async {
      final file = _createReadOnlyFile(
          'test_str', OpenFlags.rightReadable | OpenFlags.describe);

      await file.proxy.onOpen.first.then((response) {
        expect(response.s, ZX.OK);
        expect(response.info, isNotNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    test('onOpen with NodeReference flag', () async {
      final file = _createReadOnlyFile(
          'test_str', OpenFlags.nodeReference | OpenFlags.describe);

      await file.proxy.onOpen.first.then((response) {
        expect(response.s, ZX.OK);
        expect(response.info, isNotNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    test('Directory not ignored with NodeReference flag', () async {
      final file = _createReadOnlyFile(
          'test_str',
          OpenFlags.nodeReference | OpenFlags.describe | OpenFlags.directory,
          ZX.ERR_NOT_DIR);

      await file.proxy.onOpen.first.then((response) {
        expect(response.s, ZX.ERR_NOT_DIR);
        expect(response.info, isNull);
      }).catchError((err) async {
        fail(err.toString());
      });
    });

    test('GetAttr with NodeReference flag', () async {
      final file = _createReadOnlyFile('test_str', OpenFlags.nodeReference);
      final response = await file.proxy.getAttr();
      expect(response.s, ZX.OK);
      expect(response.attributes, expectedNodeAttrs);
    });

    test('read file', () async {
      const str = 'test_str';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);
      await _assertRead(file.proxy, 10, str);
    });

    test('read functions fails for NodeReference flag', () async {
      final file = _createReadOnlyFile(
          'test_str', OpenFlags.rightReadable | OpenFlags.nodeReference);
      await expectLater(
          file.proxy.read(1024),
          throwsA(isA<MethodException>()
              .having((e) => e.value, 'value', equals(ZX.ERR_ACCESS_DENIED))));

      await expectLater(
          file.proxy.readAt(0, 1024),
          throwsA(isA<MethodException>()
              .having((e) => e.value, 'value', equals(ZX.ERR_ACCESS_DENIED))));
    });

    Future<void> _resetSeek(FileProxy proxy, [int? offset]) async {
      // Reset seek.
      int _ = await proxy.seek(SeekOrigin.start, offset ?? 0);
    }

    test('simple write file', () async {
      const str = 'test_str';
      final file = _createReadWriteFile(str);
      final proxy = file.proxy;

      await _assertWrite(proxy, _newStrList);

      await _resetSeek(proxy);

      await _assertRead(file.proxy, 100, _newStr);

      await _assertFinalBuffer(file.proxy, file, str, _newStr);
    });

    test('readAt', () async {
      const str = 'test_str';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);

      for (int i = 0; i < str.length; i++) {
        await _assertReadAt(file.proxy, 100, i, str.substring(i));
      }
    });

    test('read after readAt', () async {
      const str = 'test_str';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);

      await _assertReadAt(file.proxy, 100, 1, str.substring(1));

      //readAt should not change seek
      await _assertRead(file.proxy, 100, str);
    });

    test('read should not affect readAt', () async {
      const str = 'test_str';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);

      await _assertRead(file.proxy, 100, str);

      // after seek is changed, readAt should be able to read at any position
      await _assertReadAt(file.proxy, 100, 2, str.substring(2));
    });

    test('readAt should work for arbitrary length', () async {
      const str = 'test_str';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);

      // try to read 3 chars
      await _assertReadAt(file.proxy, 3, 2, str.substring(2, 2 + 3));
    });

    test('read should work after readAt read arbitrary length', () async {
      const str = 'test_str';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);

      await _assertReadAt(file.proxy, 3, 2, str.substring(2, 2 + 3));

      await _assertRead(file.proxy, 3, str.substring(0, 0 + 3));
    });

    test('readAt should fail for passing offset more than length of file',
        () async {
      const str = 'test_str';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);

      await _assertReadAt(file.proxy, 100, str.length + 1, '',
          expectedStatus: ZX.ERR_OUT_OF_RANGE);
    });

    test('readAt should not fail for passing offset equal to length of file',
        () async {
      const str = 'test_str';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);

      await _assertReadAt(file.proxy, 100, str.length, '');
    });

    test('read should not fail for reading from end of file', () async {
      const str = 'test_str';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);

      await _resetSeek(file.proxy, str.length);
      await _assertRead(file.proxy, 100, '');
    });

    test('write file at arbitrary position', () async {
      const str = 'test_str';
      final file = _createReadWriteFile(str);
      final proxy = file.proxy;

      await _resetSeek(proxy, 1);

      await _assertWrite(proxy, _newStrList);

      await _resetSeek(proxy);

      final expectedStr = str.substring(0, 1) + _newStr;
      await _assertRead(proxy, 100, expectedStr);

      await _assertFinalBuffer(proxy, file, str, expectedStr);
    });

    test('write should truncate if not enough capacity', () async {
      const str = 'test_str';
      final file = _createReadWriteFile(str);
      final proxy = file.proxy;

      await _resetSeek(proxy, 2);
      await _assertWrite(proxy, _newStrList, expectedSize: _newStr.length - 1);
      await _resetSeek(proxy);

      final expectedStr =
          str.substring(0, 2) + _newStr.substring(0, _newStr.length - 1);
      await _assertRead(proxy, 100, expectedStr);

      await _assertFinalBuffer(proxy, file, str, expectedStr);
    });

    test('write at end should fail', () async {
      const str = 'test_str';
      final file = _createReadWriteFile(str);
      final proxy = file.proxy;

      await _resetSeek(proxy, str.length);
      await _assertWrite(proxy, _newStrList,
          expectedStatus: ZX.ERR_OUT_OF_RANGE, expectedSize: 0);

      await _resetSeek(proxy);

      await _assertRead(proxy, 100, str);

      await _assertFinalBuffer(proxy, file, str, str);
    });

    group('write file when capacity is not initial length:', () {
      test('should not resize if there is enough capacity', () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str, capacity: str.length + 2);
        final proxy = file.proxy;

        await _resetSeek(proxy, 3);
        await _assertWrite(proxy, _newStrList);

        final expectedStr =
            str.substring(0, 3) + _newStr.substring(0, _newStr.length);
        await _assertReadAt(proxy, 100, 0, expectedStr);

        await _assertFinalBuffer(proxy, file, str, expectedStr);
      });

      test('write should fail when capacity is reached', () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str, capacity: str.length + 2);
        final proxy = file.proxy;

        await _resetSeek(proxy, 3);
        await _assertWrite(proxy, _newStrList);

        final expectedStr =
            str.substring(0, 3) + _newStr.substring(0, _newStr.length);

        // write at end, should fail
        await _resetSeek(proxy, expectedStr.length);
        await _assertWrite(proxy, _newStrList,
            expectedStatus: ZX.ERR_OUT_OF_RANGE, expectedSize: 0);

        // no write should have happened
        await _assertReadAt(proxy, 100, 0, expectedStr);

        await _assertFinalBuffer(proxy, file, str, expectedStr);
      });

      test('write to end of initial len', () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str, capacity: str.length + 2);
        final proxy = file.proxy;
        await _resetSeek(proxy, str.length);

        // write at end
        await _assertWrite(proxy, _newStrList, expectedSize: 2);

        final expectedStr = str + _newStr.substring(0, 2);
        await _assertReadAt(proxy, 100, 0, expectedStr);

        await _assertFinalBuffer(proxy, file, str, expectedStr);
      });

      test('writeAt should not depend on seek', () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str, capacity: str.length + 2);
        final proxy = file.proxy;
        await _resetSeek(proxy, str.length);

        // seek is at end, write at 2nd position
        await _assertWriteAt(proxy, _newStrList, 2, _newStrList.length);

        // seek should not have changed
        final expectedStr = str.substring(0, 2) + _newStr;
        await _assertRead(proxy, 100, expectedStr.substring(str.length));

        await _assertFinalBuffer(proxy, file, str, expectedStr);
      });

      test('writeAt - end of file with', () async {
        const str = 'test_str';

        // writeAt should be able to write at end of the file
        final file = _createReadWriteFile(str, capacity: str.length + 5);
        final proxy = file.proxy;

        await _assertWriteAt(proxy, _newStrList, str.length, 5);

        final expectedStr = str + _newStr.substring(0, 5);
        await _assertRead(proxy, 100, expectedStr);

        await _assertFinalBuffer(proxy, file, str, expectedStr);
      });

      test('writeAt should fail for trying to write beyond end of file',
          () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str, capacity: str.length + 5);
        final proxy = file.proxy;

        await _assertWriteAt(proxy, _newStrList, str.length + 1, 0,
            expectedStatus: ZX.ERR_OUT_OF_RANGE);

        await _assertRead(proxy, 100, str);

        await _assertFinalBuffer(proxy, file, str, str);
      });

      test('write functions fails for NodeReference flag', () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str,
            capacity: str.length + 5,
            flags: OpenFlags.rightWritable | OpenFlags.nodeReference);
        final proxy = file.proxy;

        await _assertWriteAt(proxy, _newStrList, str.length + 1, 0,
            expectedStatus: ZX.ERR_ACCESS_DENIED);

        await _assertWrite(proxy, _newStrList,
            expectedSize: 0, expectedStatus: ZX.ERR_ACCESS_DENIED);
      });
    });

    test('various seek positions and reads', () async {
      const str = 'a very big string';
      final file = _createReadOnlyFile(str, OpenFlags.rightReadable);
      final proxy = file.proxy;

      {
        const c = 5;
        final data = await proxy.read(5);
        expect(String.fromCharCodes(data), str.substring(0, c));
      }

      var lastOffset = 5;
      {
        const c = 6;
        final data = await proxy.read(6);
        expect(String.fromCharCodes(data),
            str.substring(lastOffset, lastOffset + c));
      }

      {
        const c = 10;
        int offsetFromStart = await proxy.seek(SeekOrigin.start, c);
        expect(offsetFromStart, c);
        final data = await proxy.read(100);
        expect(String.fromCharCodes(data), str.substring(c));
      }

      {
        const c = 2;
        final offsetFromStart = await proxy.seek(SeekOrigin.start, c);
        expect(offsetFromStart, c);
        lastOffset = c;
      }

      {
        const c = 5;
        final offsetFromStart = await proxy.seek(SeekOrigin.current, c);
        expect(offsetFromStart, c + lastOffset);
        lastOffset = offsetFromStart;
        final data = await proxy.read(100);
        expect(String.fromCharCodes(data), str.substring(lastOffset));
      }

      {
        const c = 0;
        final offsetFromStart = await proxy.seek(SeekOrigin.end, c);
        expect(offsetFromStart, str.length - 1);
      }

      {
        const c = -3;
        final offsetFromStart = await proxy.seek(SeekOrigin.end, c);
        expect(offsetFromStart, str.length - 1 + c);
        final data = await proxy.read(100);
        expect(String.fromCharCodes(data), str.substring(offsetFromStart));
      }

      // Check edge and error conditions
      {
        const c = 3;
        await expectLater(
            proxy.seek(SeekOrigin.end, c),
            throwsA(isA<MethodException>()
                .having((e) => e.value, 'value', equals(ZX.ERR_OUT_OF_RANGE))));
      }

      {
        const c = -3;
        await expectLater(
            proxy.seek(SeekOrigin.start, c),
            throwsA(isA<MethodException>()
                .having((e) => e.value, 'value', equals(ZX.ERR_OUT_OF_RANGE))));
      }

      {
        const c = 5;
        final offsetFromStart = await proxy.seek(SeekOrigin.start, c);
        await expectLater(
            proxy.seek(SeekOrigin.current, str.length - offsetFromStart + 1),
            throwsA(isA<MethodException>()
                .having((e) => e.value, 'value', equals(ZX.ERR_OUT_OF_RANGE))));
      }
    });

    group('resize: ', () {
      test('failure test', () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str, createProxy: false);

        final proxy = FileProxy();
        expect(
            file.pseudoFile.connect(
                OpenFlags.rightReadable, 0, _getNodeInterfaceRequest(proxy)),
            ZX.OK);
        await expectLater(
            proxy.resize(3),
            throwsA(isA<MethodException>().having(
                (e) => e.value, 'value', equals(ZX.ERR_ACCESS_DENIED))));

        await _assertRead(proxy, 100, str);

        await _assertFinalBuffer(proxy, file, str, str);
      });

      test('basic', () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str);
        final proxy = file.proxy;

        await proxy.resize(3);

        final expectedStr = str.substring(0, 3);

        await _assertRead(proxy, 100, expectedStr);

        await _assertFinalBuffer(proxy, file, str, expectedStr);
      });

      test('on open', () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str, createProxy: false);
        final proxy = FileProxy();
        expect(
            file.pseudoFile.connect(
                OpenFlags.rightReadable |
                    OpenFlags.rightWritable |
                    OpenFlags.truncate,
                0,
                _getNodeInterfaceRequest(proxy)),
            ZX.OK);

        await _assertFinalBuffer(proxy, file, str, '');
      });

      test('with seek', () async {
        const str = 'test_str';
        final file = _createReadWriteFile(str);
        final proxy = file.proxy;

        await _resetSeek(proxy, 5);

        await proxy.resize(3);

        // seek and currentLen should be 3 so we should not get any data
        await _assertRead(proxy, 100, '');

        // resize should have worked
        await _assertReadAt(proxy, 100, 0, str.substring(0, 3));
      });

      test('close should work', () async {
        const str = 'test_str';
        final file = _createReadOnlyFile(str, OpenFlags.rightReadable);
        // make sure file was opened
        file.pseudoFile.close();

        file.proxy.ctrl.whenClosed.asStream().listen(expectAsync1((_) {}));
      });
    });
  });
}

class _ReadOnlyFile {
  late PseudoFile pseudoFile;
  late FileProxy proxy;
}

class _ReadWriteFile {
  String? buffer;
  late PseudoFile pseudoFile;
  late FileProxy proxy;
}