StandardCrawlerContainer container = new StandardCrawlerContainer();
        
        // Configure basic components
        container.singleton("crawler", Crawler.class)
                .singleton("httpClient", HcHttpClient.class)
                .singleton("fileTransformer", FileTransformer.class);
        
        // Get crawler instance
        Crawler crawler = container.getComponent("crawler");
        

     * @return this container instance for method chaining
     */
    public <T> StandardCrawlerContainer singleton(final String name, final Class<T> cls, final Consumer<T> initializer) {
        return singleton(name, cls, initializer, (Consumer<T>) null);
    }

    /**
     * Registers a singleton component with the specified name and class.
     * One instance will be shared throughout the container's lifecycle.

                .singleton("dataHelper", MemoryDataHelper.class)//
                .singleton("urlFilterService", UrlFilterServiceImpl.class)//
                .singleton("urlFilter", UrlFilterImpl.class)//
                .singleton("robotsTxtHelper", RobotsTxtHelper.class)//
                .singleton("httpClient", HcHttpClient.class);

                .singleton("urlConvertHelper", UrlConvertHelper.class)
                .singleton("intervalController", DefaultIntervalController.class)
                .singleton("sitemapsHelper", SitemapsHelper.class)
                .singleton("logHelper", LogHelperImpl.class)
                .singleton("encodingHelper", EncodingHelper.class)
                .singleton("contentLengthHelper", ContentLengthHelper.class)

        .addEqualityGroup(
            singleton(1),
            union(singleton(1), singleton(1)),
            intersection(newHashSet(1, 2), newHashSet(1, 3)),
            difference(newHashSet(1, 2), newHashSet(2, 3)),
            symmetricDifference(newHashSet(1, 2, 3), newHashSet(2, 3)))
        .addEqualityGroup(
            singleton(2),
            union(singleton(2), singleton(2)),

    if (supportsRemove) {
      int initialSize = map.size();
      assertTrue(keys.removeAll(singleton(key)));
      assertEquals(initialSize - 1, map.size());
      assertFalse(map.containsKey(key));
    } else {
      assertThrows(UnsupportedOperationException.class, () -> keys.removeAll(singleton(key)));
    }
    assertInvariants(map);
  }

  public void testKeySetRetainAll() {

    assertEquals(singleton("bar"), set);
    set.clear();
    assertTrue(set.isEmpty());
    assertEquals(singleton("foo"), sortedTable.rowKeySet());
  }

  public void testRowKeySetTailSet() {
    sortedTable = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    Set<String> set = sortedTable.rowKeySet().tailSet("cat");
    assertEquals(singleton("foo"), set);
    set.clear();

    Collection<String> c = MinimalCollection.of("a");
    Set<String> set = copyOf(c);
    assertEquals(singleton("a"), set);
  }

  public void testCopyOf_collection_oneElementRepeated() {
    Collection<String> c = MinimalCollection.of("a", "a", "a");
    Set<String> set = copyOf(c);
    assertEquals(singleton("a"), set);
  }

  public void testCopyOf_collection_general() {

        // Initialize container with test components
        container = new StandardCrawlerContainer().prototype("testComponent", TestComponent.class)
                .singleton("singletonComponent", SingletonTestComponent.class)
                .singleton("factory", CrawlerPooledObjectFactory.class);

        factory = new CrawlerPooledObjectFactory<>();
        factory.crawlerContainer = container;
    }

    /**

    assertEquals(ImmutableRangeSet.<Integer>all(), rangeSet.complement());
    assertFalse(rangeSet.contains(0));
    assertFalse(rangeSet.intersects(Range.singleton(0)));
    assertFalse(rangeSet.encloses(Range.singleton(0)));
    assertTrue(rangeSet.enclosesAll(rangeSet));
    assertTrue(rangeSet.isEmpty());
  }

  public void testAll() {