content: /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.camel.component.ehcache;
  
  import java.net.URL;
  import java.security.SecureRandom;
  import java.util.Arrays;
  import java.util.List;
  import java.util.Map;
  import java.util.UUID;
  import java.util.stream.Collectors;
  import java.util.stream.IntStream;
  
  import org.apache.camel.BindToRegistry;
  import org.apache.camel.component.ehcache.processor.aggregate.EhcacheAggregationRepository;
  import org.apache.camel.support.DefaultExchangeHolder;
  import org.apache.camel.test.junit5.CamelTestSupport;
  import org.ehcache.Cache;
  import org.ehcache.CacheManager;
  import org.ehcache.config.Configuration;
  import org.ehcache.config.builders.CacheManagerBuilder;
  import org.ehcache.xml.XmlConfiguration;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  public class EhcacheTestSupport extends CamelTestSupport {
      public static final Logger LOGGER = LoggerFactory.getLogger(EhcacheTestSupport.class);
      public static final String EHCACHE_CONFIG = "/ehcache/ehcache-config.xml";
      public static final String TEST_CACHE_NAME = "mycache";
      public static final String IDEMPOTENT_TEST_CACHE_NAME = "idempotent";
      public static final String AGGREGATE_TEST_CACHE_NAME = "aggregate";
  
      @BindToRegistry("cacheManager")
      protected CacheManager cacheManager;
  
      @Override
      protected void doPreSetup() throws Exception {
          final URL url = this.getClass().getResource(EHCACHE_CONFIG);
          final Configuration xmlConfig = new XmlConfiguration(url);
  
          cacheManager = CacheManagerBuilder.newCacheManager(xmlConfig);
          cacheManager.init();
      }
  
      @Override
      public void doPostTearDown() {
          if (cacheManager != null) {
              cacheManager.close();
          }
      }
  
      protected Cache<Object, Object> getCache(String name) {
          return cacheManager.getCache(name, Object.class, Object.class);
      }
  
      protected Cache<Object, Object> getTestCache() {
          return cacheManager.getCache(TEST_CACHE_NAME, Object.class, Object.class);
      }
  
      protected Cache<String, Boolean> getIdempotentCache() {
          return cacheManager.getCache(IDEMPOTENT_TEST_CACHE_NAME, String.class, Boolean.class);
      }
  
      protected Cache<String, DefaultExchangeHolder> getAggregateCache() {
          return cacheManager.getCache(AGGREGATE_TEST_CACHE_NAME, String.class, DefaultExchangeHolder.class);
      }
  
      protected EhcacheAggregationRepository createAggregateRepository() {
          EhcacheAggregationRepository repository = new EhcacheAggregationRepository();
          repository.setCache(getAggregateCache());
          repository.setCacheName("aggregate");
  
          return repository;
      }
  
      protected static int[] generateRandomArrayOfInt(int size, int lower, int upper) {
          SecureRandom random = new SecureRandom();
          int[] array = new int[size];
  
          Arrays.setAll(array, i -> random.nextInt(upper - lower) + lower);
  
          return array;
      }
  
      protected static String generateRandomString() {
          return UUID.randomUUID().toString();
      }
  
      protected static String[] generateRandomArrayOfStrings(int size) {
          String[] array = new String[size];
          Arrays.setAll(array, i -> generateRandomString());
  
          return array;
      }
  
      protected static List<String> generateRandomListOfStrings(int size) {
          return Arrays.asList(generateRandomArrayOfStrings(size));
      }
  
      protected static Map<String, String> generateRandomMapOfString(int size) {
          return IntStream.range(0, size).boxed().collect(Collectors.toMap(
                  i -> i + "-" + generateRandomString(),
                  i -> i + "-" + generateRandomString()));
      }
  }
  