## Overview

Replication relies on immutability provided by versioning to sync objects between the configured source and replication target. Replication results in the object data, metadata, last modification time and version ID all being identical between the source and target. Thus version ordering is automatically guaranteed on the source and target clusters.

### Replication of object version and metadata

        mockNotifications.add(fileNotifyInfo1);
        mockNotifications.add(fileNotifyInfo2);
        mockNotifications.add(fileNotifyInfo3);
    }

    /**
     * Test watch() method returning notifications
     */
    @Test
    void testWatch() throws CIFSException {
        // Setup mock behavior
        when(watchHandle.watch()).thenReturn(mockNotifications);

        // Execute

    }

    // Happy path for SMB2: a response is received and the list is returned; tree is closed
    @Test
    @DisplayName("watch() SMB2 happy path returns notifications and closes tree")
    void watch_smb2_success_returnsList_andClosesTree() throws Exception {
        List<FileNotifyInformation> info = new ArrayList<>();
        NotifyResponse resp = mock(NotifyResponse.class);

Luego tu API (imaginemos):

* Enviará la factura a algún cliente del desarrollador externo.
* Recogerá el dinero.
* Enviará una notificación de vuelta al usuario de la API (el desarrollador externo).
    * Esto se hará enviando un request POST (desde *tu API*) a alguna *API externa* proporcionada por ese desarrollador externo (este es el "callback").

   *
   * <p>Note: this method is idempotent and safe to call from any thread
   */
  public void dispatch() {
    // iterate by index to avoid concurrent modification exceptions
    for (int i = 0; i < listeners.size(); i++) {
      listeners.get(i).dispatch();
    }
  }

  /**
   * A special purpose queue/executor that dispatches listener events serially on a configured

     * Constructs a new CharMappingFile instance.
     *
     * @param id the unique identifier for this mapping file
     * @param path the file path to the character mapping dictionary
     * @param timestamp the last modification timestamp of the file
     */
    public CharMappingFile(final String id, final String path, final Date timestamp) {
        super(id, path, timestamp);
    }

    /**

         * Gets the size of this cached file in bytes
         * @return the file size
         */
        public long getSize() {
            return size;
        }

        /**
         * Gets the last modification timestamp of this cached item
         * @return the last modified time
         */
        public long getLastModified() {
            return lastModified;
        }

        /**

   * allocated, the value of {@code metadata} combines the number of bits in the "short hash", in
   * its bottom {@value CompactHashing#HASH_TABLE_BITS_MAX_BITS} bits, with a modification count in
   * the remaining bits that is used to detect concurrent modification during iteration.
   */
  private transient int metadata;

  /** The number of elements contained in the set. */
  private transient int size;

// The slice is valid for use only until the next buffer modification (that is,
// only until the next call to a method like [Buffer.Read], [Buffer.Write], [Buffer.Reset], or [Buffer.Truncate]).
// The slice aliases the buffer content at least until the next buffer modification,
// so immediate changes to the slice will affect the result of future reads.

    /** Policy information level for server role. */
    public static final int POLICY_INFO_SERVER_ROLE = 6;
    /** Policy information class for modification. */
    /** Policy information level for modification details. */
    public static final int POLICY_INFO_MODIFICATION = 9;
    /** Policy information class for DNS domain. */
    /** Policy information level for DNS domain information. */