def METHOD_NAME(
    uvm_nano, microvm_factory, bin_vsock_path, test_fc_session_root_path
):
    """
    Vsock transport reset test.
    Steps:
    1. Start echo server on the guest
    2. Start host workers that ping-pong data between guest and host,
    without closing any of them
    3. Pause VM -> Create snapshot -> Resume VM
    4. Check that worker sockets no longer work by setting a timeout
    so the sockets won't block and do a recv operation.
    5. If the recv operation timeouts, the connection was closed.
       Else, the connection was not closed and the test fails.
    6. Close VM -> Load VM from Snapshot -> check that vsock
       device is still working.
    """
    test_vm = uvm_nano
    test_vm.add_net_iface()
    test_vm.api.vsock.put(vsock_id="vsock0", guest_cid=3, uds_path=f"/{VSOCK_UDS_PATH}")
    test_vm.start()
    # Generate the random data blob file.
    blob_path, blob_hash = make_blob(test_fc_session_root_path)
    vm_blob_path = "/tmp/vsock/test.blob"
    # Set up a tmpfs drive on the guest, so we can copy the blob there.
    # Guest-initiated connections (echo workers) will use this blob.
    _copy_vsock_data_to_guest(test_vm.ssh, blob_path, vm_blob_path, bin_vsock_path)
    # Start guest echo server.
    path = os.path.join(test_vm.jailer.chroot_path(), VSOCK_UDS_PATH)
    cmd = f"/tmp/vsock_helper echosrv -d {ECHO_SERVER_PORT}"
    ecode, _, _ = test_vm.ssh.run(cmd)
    assert ecode == 0
    # Start host workers that connect to the guest server.
    workers = []
    for _ in range(TEST_WORKER_COUNT):
        worker = HostEchoWorker(path, blob_path)
        workers.append(worker)
        worker.start()
    for wrk in workers:
        wrk.join()
    # Create snapshot.
    snapshot = test_vm.snapshot_full()
    test_vm.resume()
    # Check that sockets are no longer working on workers.
    for worker in workers:
        # Whatever we send to the server, it should return the same
        # value.
        buf = bytearray("TEST\n".encode("utf-8"))
        worker.sock.send(buf)
        try:
            # Arbitrary timeout, we set this so the socket won't block as
            # it shouldn't receive anything.
            worker.sock.settimeout(0.25)
            response = worker.sock.recv(32)
            if response != b"":
                # If we reach here, it means the connection did not close.
                assert False, "Connection not closed: response recieved '{}'".format(
                    response.decode("utf-8")
                )
        except SocketTimeout:
            assert True
    # Terminate VM.
    test_vm.kill()
    # Load snapshot.
    vm2 = microvm_factory.build()
    vm2.spawn()
    vm2.restore_from_snapshot(snapshot, resume=True)
    # Check that vsock device still works.
    # Test guest-initiated connections.
    path = os.path.join(vm2.path, make_host_port_path(VSOCK_UDS_PATH, ECHO_SERVER_PORT))
    check_guest_connections(vm2, path, vm_blob_path, blob_hash)
    # Test host-initiated connections.
    path = os.path.join(vm2.jailer.chroot_path(), VSOCK_UDS_PATH)
    check_host_connections(vm2, path, blob_path, blob_hash)