Example:

```sh
export MINIO_DOMAIN=mydomain.com
minio server /data
```

For advanced use cases `MINIO_DOMAIN` environment variable supports multiple-domains with comma separated values.

```sh
export MINIO_DOMAIN=sub1.mydomain.com,sub2.mydomain.com
minio server /data
```

## Explore Further

            concreteImplementation.setCacheMap(cacheMap);

            // Should not throw
            assertDoesNotThrow(() -> concreteImplementation.replaceCache());

            // Map should remain empty
            assertTrue(cacheMap.isEmpty());
        }

        @Test
        @DisplayName("Should handle replace without map")
        void testReplaceCacheWithoutMap() {

            assertEquals(mockDigest, nextMessage.getDigest());
        }
    }

    @Nested
    @DisplayName("Payload Tests")
    class PayloadTests {

        @Test
        @DisplayName("Should retain payload when requested")
        void testRetainPayload() {
            assertFalse(testMessage.isRetainPayload());
            testMessage.retainPayload();
            assertTrue(testMessage.isRetainPayload());

    }

    public void test_setSessionId_same() throws Exception {
        final String originalSessionId = crawler.getSessionId();

        crawler.setSessionId(originalSessionId);

        // Should remain the same
        assertEquals(originalSessionId, crawler.getSessionId());
    }

    public void test_addIncludeFilter() throws Exception {
        crawler.addIncludeFilter("http://example\\.com/.*");

        // have been resolved.
        if (request.isResolveRoot()) {
            // Add the root artifact (as the first artifact to retain logical order of class path!)
            Set<Artifact> allArtifacts = new LinkedHashSet<>();
            allArtifacts.add(rootArtifact);
            allArtifacts.addAll(result.getArtifacts());

    /*
     * If greatestOf() promised to be implemented as reverse().leastOf(), this
     * test would be enough. It doesn't... but we'll cheat and act like it does
     * anyway. There's a comment there to remind us to fix this if we change it.
     */
    List<Integer> list = asList(3, 1, 3, 2, 4, 2, 4, 3);
    assertEquals(asList(4, 4, 3, 3), numberOrdering.greatestOf(list, 4));
  }

    /*
     * If greatestOf() promised to be implemented as reverse().leastOf(), this
     * test would be enough. It doesn't... but we'll cheat and act like it does
     * anyway. There's a comment there to remind us to fix this if we change it.
     */
    List<Integer> list = asList(3, 1, 3, 2, 4, 2, 4, 3);
    assertEquals(asList(4, 4, 3, 3), numberOrdering.greatestOf(list, 4));
  }

labels.search_result_similar=Résultats similaires ({0})
labels.facet_label_title=Étiquette
labels.facet_timestamp_title=Heure
labels.facet_timestamp_1day=Dans les 24 heures
labels.facet_timestamp_1week=Dans la semaine
labels.facet_timestamp_1month=Dans le mois
labels.facet_timestamp_1year=Dans l'année
labels.facet_timestamp_3month=Dans les 3 mois
labels.facet_timestamp_6month=Dans les 6 mois
labels.facet_timestamp_2year=Dans les 2 ans

   * iterated are the individual subsets created. Each of these subsets occupies an additional O(n)
   * memory but only for as long as the user retains a reference to it. That is, the set returned by
   * {@code combinations} does not retain the individual subsets.
   *
   * @param set the set of elements to take combinations of
   * @param size the number of elements per combination

    final ListenerCallQueue<Listener> listeners = new ListenerCallQueue<>();

    /**
     * It is implicitly assumed that all the services are NEW and that they will all remain NEW
     * until all the Listeners are installed and {@link #markReady()} is called. It is our caller's
     * responsibility to only call {@link #markReady()} if all services were new at the time this