[FileSystemFileHandle-cross-primitive-locking.https.tentative.worker.html]
  expected:
    if (os == "win") and debug: [TIMEOUT, OK]
    if (os == "win") and not debug: [TIMEOUT, OK]
    if (os == "mac") and not debug: [OK, TIMEOUT]
  [After a file has finished moving, that file can have an open access handle in readwrite mode]
    expected:
      if (os == "win") and not debug: [FAIL, TIMEOUT, NOTRUN]
      FAIL

  [A file with an ongoing remove operation does not interfere with the creation of an open access handle in readwrite mode on another file]
    expected:
      if (os == "win") and not debug: [FAIL, TIMEOUT, NOTRUN]
      FAIL

  [After a file has finished being removed, that file can have an open access handle in readwrite mode]
    expected:
      if (os == "win") and not debug: [FAIL, TIMEOUT, NOTRUN]
      FAIL

  [A directory cannot be removed if it contains a file that has an open access handle in readwrite mode.]
    expected:
      if (os == "win") and not debug: [FAIL, TIMEOUT, NOTRUN]
      FAIL

  [A file with an open access handle in readwrite mode cannot be removed]
    expected:
      if (os == "win") and not debug: [FAIL, TIMEOUT, NOTRUN]
      FAIL

  [A file with an open access handle in readwrite mode does not interfere with removing another file]
    expected:
      if (os == "win") and not debug: [FAIL, TIMEOUT, NOTRUN]
      FAIL

  [After an open access handle in readwrite mode on a file has been closed, that file can be removed]
    expected:
      if (os == "win") and not debug: [FAIL, TIMEOUT, NOTRUN]
      FAIL

  [After a file has finished moving, that file can have an open access handle in read-only mode]
    expected:
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file with an ongoing remove operation does not interfere with the creation of an open access handle in read-only mode on another file]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [After a file has finished being removed, that file can have an open access handle in read-only mode]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A directory cannot be removed if it contains a file that has an open access handle in read-only mode.]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file with an open access handle in read-only mode cannot be removed]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file with an open access handle in read-only mode does not interfere with removing another file]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [After an open access handle in read-only mode on a file has been closed, that file can be removed]
    expected:
      if (os == "win") and debug: [FAIL, TIMEOUT, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file with an open access handle in read-only mode does not interfere with the creation of an open writable stream in siloed mode on another file]
    expected:
      if (os == "win") and debug: [PASS, TIMEOUT, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open writable stream in exclusive mode on a file, cannot have an open access handle in read-only mode on that same file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open writable stream in exclusive mode does not interfere with an open access handle in read-only mode on another file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After a writable stream in exclusive mode has been closed for a file, that file can have an open access handle in read-only mode]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open access handle in read-only mode on a file, cannot open an open writable stream in exclusive mode on that same file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open access handle in read-only mode does not interfere with the creation of an open writable stream in exclusive mode on another file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an ongoing move operation does not interfere with an open access handle in readwrite-unsafe mode on another file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After a file has finished moving, that file can have an open access handle in readwrite-unsafe mode]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file cannot be moved to a location with an open access handle in readwrite-unsafe mode]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open access handle in readwrite-unsafe mode cannot be moved]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open access handle in readwrite-unsafe mode does not interfere with moving another file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After an open access handle in readwrite-unsafe mode on a file has been closed, that file can be moved]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an ongoing remove operation does not interfere with the creation of an open access handle in readwrite-unsafe mode on another file]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [After a file has finished being removed, that file can have an open access handle in readwrite-unsafe mode]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A directory cannot be removed if it contains a file that has an open access handle in readwrite-unsafe mode.]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file with an open access handle in readwrite-unsafe mode cannot be removed]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file with an open access handle in readwrite-unsafe mode does not interfere with removing another file]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [After an open access handle in readwrite-unsafe mode on a file has been closed, that file can be removed]
    expected:
      if (os == "win") and debug: [FAIL, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [When there's an open writable stream in siloed mode on a file, cannot have an open access handle in readwrite-unsafe mode on that same file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open writable stream in siloed mode does not interfere with an open access handle in readwrite-unsafe mode on another file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After all writable streams in siloed mode have been closed for a file, that file can have an open access handle in readwrite-unsafe mode]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open access handle in readwrite-unsafe mode on a file, cannot open an open writable stream in siloed mode on that same file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open access handle in readwrite-unsafe mode does not interfere with the creation of an open writable stream in siloed mode on another file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open writable stream in exclusive mode on a file, cannot have an open access handle in readwrite-unsafe mode on that same file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open writable stream in exclusive mode does not interfere with an open access handle in readwrite-unsafe mode on another file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After a writable stream in exclusive mode has been closed for a file, that file can have an open access handle in readwrite-unsafe mode]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open access handle in readwrite-unsafe mode on a file, cannot open an open writable stream in exclusive mode on that same file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open access handle in readwrite-unsafe mode does not interfere with the creation of an open writable stream in exclusive mode on another file]
    expected:
      if (os == "win") and debug: [TIMEOUT, PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an ongoing move operation does not interfere with an open writable stream in siloed mode on another file]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After a file has finished moving, that file can have an open writable stream in siloed mode]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL, TIMEOUT]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file cannot be moved to a location with an open writable stream in siloed mode]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS]
      if (os == "win") and not debug: [NOTRUN, PASS]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open writable stream in siloed mode on a file, cannot have an ongoing move operation on that same file]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS]
      if (os == "win") and not debug: [NOTRUN, PASS]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open writable stream in siloed mode does not interfere with an ongoing move operation on another file]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS]
      if (os == "win") and not debug: [NOTRUN, PASS]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After all writable streams in siloed mode have been closed for a file, that file can have an ongoing move operation]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS, TIMEOUT]
      if (os == "win") and not debug: [NOTRUN, PASS]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an ongoing remove operation does not interfere with the creation of an open writable stream in siloed mode on another file]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [After a file has finished being removed, that file can have an open writable stream in siloed mode]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A directory cannot be removed if it contains a file that has an open writable stream in siloed mode.]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [When there's an open writable stream in siloed mode on a file, cannot have an ongoing remove operation on that same file]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file with an open writable stream in siloed mode does not interfere with an ongoing remove operation on another file]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [After all writable streams in siloed mode have been closed for a file, that file can have an ongoing remove operation]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file with an ongoing move operation does not interfere with an open writable stream in exclusive mode on another file]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS]
      if (os == "win") and not debug: [NOTRUN, PASS]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After a file has finished moving, that file can have an open writable stream in exclusive mode]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file cannot be moved to a location with an open writable stream in exclusive mode]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS]
      if (os == "win") and not debug: [NOTRUN, PASS]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open writable stream in exclusive mode on a file, cannot have an ongoing move operation on that same file]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS]
      if (os == "win") and not debug: [NOTRUN, PASS]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open writable stream in exclusive mode does not interfere with an ongoing move operation on another file]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS]
      if (os == "win") and not debug: [NOTRUN, PASS]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After a writable stream in exclusive mode has been closed for a file, that file can have an ongoing move operation]
    expected:
      if (os == "win") and debug: [NOTRUN, PASS]
      if (os == "win") and not debug: [NOTRUN, PASS]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an ongoing remove operation does not interfere with the creation of an open writable stream in exclusive mode on another file]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL, TIMEOUT]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [After a file has finished being removed, that file can have an open writable stream in exclusive mode]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A directory cannot be removed if it contains a file that has an open writable stream in exclusive mode.]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [When there's an open writable stream in exclusive mode on a file, cannot have an ongoing remove operation on that same file]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [A file with an open writable stream in exclusive mode does not interfere with an ongoing remove operation on another file]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [After a writable stream in exclusive mode has been closed for a file, that file can have an ongoing remove operation]
    expected:
      if (os == "win") and debug: [NOTRUN, FAIL]
      if (os == "win") and not debug: [NOTRUN, FAIL]
      if (os == "mac") and not debug: [FAIL, NOTRUN]
      FAIL

  [After all writable streams in siloed mode have been closed for a file, that file can have an open access handle in readwrite mode]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]

  [A file with an open access handle in readwrite mode does not interfere with the creation of an open writable stream in exclusive mode on another file]
    expected:
      if (os == "win") and not debug: [NOTRUN, PASS, TIMEOUT]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open access handle in readwrite mode cannot be moved]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]

  [After a writable stream in exclusive mode has been closed for a file, that file can have an open access handle in readwrite mode]
    expected:
      if (os == "win") and not debug: [NOTRUN, PASS, TIMEOUT]
      if (os == "mac") and not debug: [PASS, TIMEOUT]

  [A file with an open writable stream in siloed mode does not interfere with an open access handle in read-only mode on another file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an ongoing move operation does not interfere with an open access handle in read-only mode on another file]
    expected:
      if (os == "win") and not debug: [NOTRUN, TIMEOUT]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open access handle in readwrite mode on a file, cannot open an open writable stream in siloed mode on that same file]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]

  [A file cannot be moved to a location with an open access handle in read-only mode]
    expected:
      if (os == "win") and debug: [PASS, TIMEOUT]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open access handle in read-only mode on a file, cannot open an open writable stream in siloed mode on that same file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [After all writable streams in siloed mode have been closed for a file, that file can have an open access handle in read-only mode]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an ongoing move operation does not interfere with an open access handle in readwrite mode on another file]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT]

  [After an open access handle in read-only mode on a file has been closed, that file can be moved]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open access handle in read-only mode cannot be moved]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [When there's an open access handle in readwrite mode on a file, cannot open an open writable stream in exclusive mode on that same file]
    expected:
      if (os == "win") and not debug: [NOTRUN, PASS, TIMEOUT]
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open access handle in readwrite mode does not interfere with moving another file]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]

  [A file with an open access handle in read-only mode does not interfere with moving another file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open access handle in readwrite mode does not interfere with the creation of an open writable stream in siloed mode on another file]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]

  [A file cannot be moved to a location with an open access handle in readwrite mode]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]

  [A file with an open writable stream in exclusive mode does not interfere with an open access handle in readwrite mode on another file]
    expected:
      if (os == "win") and not debug: [TIMEOUT, PASS, NOTRUN]

  [When there's an open writable stream in siloed mode on a file, cannot have an open access handle in read-only mode on that same file]
    expected:
      if (os == "win") and debug: [PASS, NOTRUN]
      if (os == "win") and not debug: NOTRUN
      if (os == "mac") and not debug: [PASS, NOTRUN]

  [A file with an open writable stream in siloed mode does not interfere with an open access handle in readwrite mode on another file]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]

  [After an open access handle in readwrite mode on a file has been closed, that file can be moved]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]

  [When there's an open writable stream in exclusive mode on a file, cannot have an open access handle in readwrite mode on that same file]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]

  [When there's an open writable stream in siloed mode on a file, cannot have an open access handle in readwrite mode on that same file]
    expected:
      if (os == "win") and not debug: [PASS, TIMEOUT, NOTRUN]