code: def test_multiserver_mode(pattern, options):
      """
      Testing NetGear's Multi-Server Mode with three unique servers
      """
      # initialize
      frame_server = None
      stream = None
      server_1 = None
      server_2 = None
      server_3 = None
      client = None
      # define client-end dict to save frames in-accordance with unique port
      client_frame_dict = {}
      try:
          # open stream
          stream = cv2.VideoCapture(return_testvideo_path())
          # define a single client
          client = NetGear(
              port=["5556", "5557", "5558"],
              pattern=pattern,
              receive_mode=True,
              logging=True,
              **options,
          )
          # define three unique server
          server_1 = NetGear(
              pattern=pattern, port="5556", logging=True, **options
          )  # at port `5556`
          server_2 = NetGear(
              pattern=pattern, port="5557", logging=True, **options
          )  # at port `5557`
          server_3 = NetGear(
              pattern=pattern, port="5558", logging=True, **options
          )  # at port `5558`
          i = 0
          while i < random.randint(10, 100):
              (grabbed, frame_server) = stream.read()
              i += 1
          # check if input frame is valid
          assert not (frame_server is None)
  
          # send frame from Server-1 to client and save it in dict
          server_1.send(frame_server)
          unique_address, frame = client.recv(
              return_data="data"
              if "bidirectional_mode" in options and pattern == 1
              else "",
          )
          client_frame_dict[unique_address] = frame
          # send frame from Server-2 to client and save it in dict
          server_2.send(frame_server)
          unique_address, frame = client.recv(
              return_data="data"
              if "bidirectional_mode" in options and pattern == 1
              else "",
          )
          client_frame_dict[unique_address] = frame
          # send frame from Server-3 to client and save it in dict
          server_3.send(frame_server)
          unique_address, frame = client.recv(
              return_data="data"
              if "bidirectional_mode" in options and pattern == 1
              else "",
          )
          client_frame_dict[unique_address] = frame
  
          # check if received frames from each unique server exactly matches input frame
          for key in client_frame_dict.keys():
              assert np.array_equal(
                  frame_server, client_frame_dict[key]
              )
  
      except Exception as e:
          if isinstance(e, (ZMQError, ValueError, RuntimeError)):
              pytest.xfail(str(e))
          else:
              pytest.fail(str(e))
      finally:
          # clean resources
          if not (stream is None):
              stream.release()
          if not (server_1 is None):
              server_1.close()
          if not (server_2 is None):
              server_2.close()
          if not (server_3 is None):
              server_3.close()
          if not (client is None):
              client.close()
  
imports: import os
  import platform
  import queue
  import cv2
  import numpy
  import pytest
  import random
  import logging
  import tempfile
  from zmq.error import ZMQError
  from vidgear.gears import NetGear, VideoGear
  from vidgear.gears.helper import logger_handler
label_desc: Use image node_id 8 for calling a global function with example usage: test_multiserver_mode(pattern, options) without return types