public static Test suite() {
    TestSuite suite = new TestSuite();

    suite.addTestSuite(ForwardingSortedSetTest.class);
    suite.addTest(
        SortedSetTestSuiteBuilder.using(
                new TestStringSortedSetGenerator() {
                  @Override
                  protected SortedSet<String> create(String[] elements) {
                    return new StandardImplForwardingSortedSet<>(

        Collection<String> activatedIds = new HashSet<>(context.getActiveProfileIds());
        Collection<String> deactivatedIds = new HashSet<>(context.getInactiveProfileIds());

        List<Profile> activeProfiles = new ArrayList<>(profiles.size());
        List<Profile> activePomProfilesByDefault = new ArrayList<>();
        boolean activatedPomProfileNotByDefault = false;

    private List<ModelProblem> problems;

    DefaultModelBuildingResult() {
        modelIds = new ArrayList<>();
        rawModels = new HashMap<>();
        activePomProfiles = new HashMap<>();
        activeExternalProfiles = new ArrayList<>();
        problems = new ArrayList<>();
    }

    DefaultModelBuildingResult(ModelBuildingResult result) {
        this();

        if (StringUtil.isBlank(regex)) {
            throw new CrawlerSystemException("A regular expression is null.");
        }
        if (client == null) {
            throw new CrawlerSystemException("CrawlerClient is null.");
        }
        int current = 0;
        boolean added = false;
        final Map<Pattern, CrawlerClient> newClientMap = new LinkedHashMap<>();

        super(name, properties);
    }

    private static final long SEED = ( new Random() ).nextLong();


    @Override
    @Before
    public void setUp () throws Exception {
        super.setUp();
    }


    static Random getRandom () {
        return new Random(SEED);
    }


    @Parameters ( name = "{0}" )
    public static Collection<Object> configs () {

   *
   * @param map the mappings to be placed in the new map
   * @return a new {@code HashMap} initialized with the mappings from {@code map}
   */
  @SuppressWarnings("NonApiType") // acts as a direct substitute for a constructor call
  public static <K extends @Nullable Object, V extends @Nullable Object> HashMap<K, V> newHashMap(
      Map<? extends K, ? extends V> map) {
    return new HashMap<>(map);
  }

  /**

    bf2.put("1");
    bf2.put("2");

    new EqualsTester().addEqualityGroup(bf1, bf2).testEquals();

    bf2.put("3");

    new EqualsTester().addEqualityGroup(bf1).addEqualityGroup(bf2).testEquals();
  }

  public void testEqualsWithCustomFunnel() {
    BloomFilter<Long> bf1 = BloomFilter.create(new CustomFunnel(), 100);
    BloomFilter<Long> bf2 = BloomFilter.create(new CustomFunnel(), 100);
    assertEquals(bf1, bf2);

        ImmutableList.of(
            ListTestSuiteBuilder.using(new ImmutableIntArrayAsListGenerator())
                .named("ImmutableIntArray.asList"),
            ListTestSuiteBuilder.using(new ImmutableIntArrayHeadSubListAsListGenerator())
                .named("ImmutableIntArray.asList, head subList"),
            ListTestSuiteBuilder.using(new ImmutableIntArrayTailSubListAsListGenerator())

        ImmutableList.of(
            ListTestSuiteBuilder.using(new ImmutableDoubleArrayAsListGenerator())
                .named("ImmutableDoubleArray.asList"),
            ListTestSuiteBuilder.using(new ImmutableDoubleArrayHeadSubListAsListGenerator())
                .named("ImmutableDoubleArray.asList, head subList"),
            ListTestSuiteBuilder.using(new ImmutableDoubleArrayTailSubListAsListGenerator())

  }

  public static <T> Callable<T> callableThrowing(final Exception exception) {
    return new Callable<T>() {
      @Override
      public T call() throws Exception {
        throw exception;
      }
    };
  }

  private static Runnable runnableThrowing(final RuntimeException e) {
    return new Runnable() {
      @Override
      public void run() {
        throw e;
      }
    };
  }