package it.com.atlassian.plugin.osgi.performance;
   
   import com.atlassian.plugin.DefaultModuleDescriptorFactory;
   import com.atlassian.plugin.hostcontainer.DefaultHostContainer;
   import com.atlassian.plugin.osgi.DummyModuleDescriptor;
   import com.atlassian.plugin.osgi.PluginInContainerTestBase;
   import com.atlassian.plugin.osgi.SomeInterface;
   import com.atlassian.plugin.osgi.hostcomponents.ComponentRegistrar;
   import com.atlassian.plugin.osgi.hostcomponents.HostComponentProvider;
  import org.junit.Test;
  import org.osgi.framework.Bundle;
  import org.osgi.framework.Constants;
  
  import java.io.File;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.TimeUnit;
  
  import static org.junit.Assert.assertEquals;
  
  /**
   * Tests the plugin framework handling restarts correctly
   */
  public abstract class FrameworkRestartTestBase extends PluginInContainerTestBase {
      private static final int NUM_HOST_COMPONENTS = 200;
      private static final int NUM_PLUGINS = 50;
      HostComponentProvider prov = null;
      DefaultModuleDescriptorFactory factory = null;
  
      @Override
      public void setUp() throws Exception {
          super.setUp();
          factory = new DefaultModuleDescriptorFactory(new DefaultHostContainer());
          factory.addModuleDescriptor("dummy", DummyModuleDescriptor.class);
          prov = new HostComponentProvider() {
              public void provide(final ComponentRegistrar registrar) {
                  for (int x = 0; x < NUM_HOST_COMPONENTS; x++) {
                      registrar.register(SomeInterface.class).forInstance(new SomeInterface() {
                      });
                  }
              }
          };
  
          ExecutorService executor = Executors.newFixedThreadPool(8);
          for (int x = 0; x < NUM_PLUGINS; x++) {
              final int run = x;
              executor.execute(new Runnable() {
                  public void run() {
                      try {
                          addPlugin(pluginsDir, run);
                      } catch (Exception e) {
                          e.printStackTrace();
                      }
                  }
              });
  
          }
          executor.shutdown();
          executor.awaitTermination(300, TimeUnit.SECONDS);
          // warm up the cache
          initPluginManager(prov, factory);
          pluginSystemLifecycle.shutdown();
      }
  
      protected abstract void addPlugin(File dir, int x) throws Exception;
  
      protected void startPluginFramework() throws Exception {
          initPluginManager(prov, factory);
          assertEquals(pluginAccessor.getPlugins().size(), pluginAccessor.getEnabledPlugins().size());
  
          for (Bundle bundle : osgiContainerManager.getBundles()) {
              final boolean isFragment = (bundle.getHeaders().get(Constants.FRAGMENT_HOST) != null);
  
              if (isFragment) {
                  assertEquals("Fragment Bundle " + bundle.getSymbolicName() + " was not resolved: " + bundle.getState(), Bundle.RESOLVED, bundle.getState());
              } else {
                  assertEquals("Bundle " + bundle.getSymbolicName() + " was not active: " + bundle.getState(), Bundle.ACTIVE, bundle.getState());
              }
          }
      }
  
      @Override
      public void tearDown() throws Exception {
          super.tearDown();
      }
  
      @Test
      public void testMultiplePlugins() throws Exception {
          startPluginFramework();
          pluginSystemLifecycle.shutdown();
      }
  }