Add ut 1221

sofa-ark-parent/core-impl/container/src/test/java/com/alipay/sofa/ark/container/BaseTest.java

@@ -33,7 +33,6 @@
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.mockito.MockedStatic;
-import org.mockito.Mockito;
 
 import java.lang.management.ManagementFactory;
 import java.lang.management.RuntimeMXBean;
@@ -43,7 +42,7 @@
 
 import static com.alipay.sofa.ark.common.util.FileUtils.file;
 import static com.alipay.sofa.ark.spi.service.extension.ArkServiceLoader.setExtensionLoaderService;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
 
 /**
  *
@@ -82,11 +81,11 @@ public void before() {
         mockArguments.add(String.format("-javaagent:%s", workingPath));
         mockArguments.add(String.format("-javaagent:%s=xx", workingPath));
 
-        RuntimeMXBean runtimeMXBean = Mockito.mock(RuntimeMXBean.class);
+        RuntimeMXBean runtimeMXBean = mock(RuntimeMXBean.class);
         when(runtimeMXBean.getInputArguments()).thenReturn(mockArguments);
         when(runtimeMXBean.getName()).thenReturn("");
 
-        managementFactoryMockedStatic = Mockito.mockStatic(ManagementFactory.class);
+        managementFactoryMockedStatic = mockStatic(ManagementFactory.class);
         managementFactoryMockedStatic.when(ManagementFactory::getRuntimeMXBean).thenReturn(runtimeMXBean);
 
         arkServiceContainer.start();

sofa-ark-parent/core-impl/container/src/test/java/com/alipay/sofa/ark/container/service/classloader/ClassLoaderServiceTest.java

@@ -16,24 +16,30 @@
  */
 package com.alipay.sofa.ark.container.service.classloader;
 
-import com.alipay.sofa.ark.common.util.AssertUtils;
 import com.alipay.sofa.ark.container.BaseTest;
 import com.alipay.sofa.ark.container.model.BizModel;
 import com.alipay.sofa.ark.container.model.PluginModel;
 import com.alipay.sofa.ark.container.service.ArkServiceContainerHolder;
 import com.alipay.sofa.ark.spi.model.Biz;
-import com.alipay.sofa.ark.spi.model.BizState;
 import com.alipay.sofa.ark.spi.model.Plugin;
 import com.alipay.sofa.ark.spi.service.biz.BizManagerService;
 import com.alipay.sofa.ark.spi.service.classloader.ClassLoaderService;
 import com.alipay.sofa.ark.spi.service.plugin.PluginManagerService;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
+import java.lang.reflect.Field;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static com.alipay.sofa.ark.common.util.AssertUtils.isFalse;
+import static com.alipay.sofa.ark.common.util.AssertUtils.isTrue;
+import static com.alipay.sofa.ark.spi.model.BizState.RESOLVED;
+import static java.util.Arrays.asList;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
 
 /**
  *
@@ -59,125 +65,119 @@ public void before() {
 
     @Test
     public void testIsSunReflect() {
-        Assert.assertTrue(classloaderService
-            .isSunReflectClass("sun.reflect.GeneratedMethodAccessor100"));
+        assertTrue(classloaderService.isSunReflectClass("sun.reflect.GeneratedMethodAccessor100"));
     }
 
     @Test
     public void testIsNotSunReflect() {
-        Assert.assertFalse(classloaderService.isSunReflectClass("test"));
+        assertFalse(classloaderService.isSunReflectClass("test"));
     }
 
     @Test
     public void testIsArkSpiClass() {
-        Assert.assertTrue(classloaderService
-            .isArkSpiClass("com.alipay.sofa.ark.spi.service.ArkService"));
+        assertTrue(classloaderService.isArkSpiClass("com.alipay.sofa.ark.spi.service.ArkService"));
     }
 
     @Test
     public void testIsNotArkSpiClass() {
-        Assert.assertFalse(classloaderService.isArkSpiClass("test"));
+        assertFalse(classloaderService.isArkSpiClass("test"));
     }
 
     @Test
     public void testJDKClassLoader() {
         String sunToolClass = "sun.tools.attach.BsdVirtualMachine";
         ClassLoader jdkClassLoader = classloaderService.getJDKClassLoader();
-        Assert.assertNotNull(jdkClassLoader);
+        assertNotNull(jdkClassLoader);
         try {
             // only when this class can be loaded from system classloader,
             // then it should be loaded successfully from jdkClassLoader
             classloaderService.getSystemClassLoader().loadClass(sunToolClass);
-            Assert.assertNotNull(jdkClassLoader.loadClass(sunToolClass));
+            assertNotNull(jdkClassLoader.loadClass(sunToolClass));
         } catch (ClassNotFoundException e) {
             // ignore
         }
-
     }
 
     @Test
     public void testArkClassLoader() {
         ClassLoader arkClassLoader = classloaderService.getArkClassLoader();
-        Assert.assertNotNull(arkClassLoader);
+        assertNotNull(arkClassLoader);
     }
 
     @Test
     public void testSystemClassLoader() {
         ClassLoader systemClassLoader = classloaderService.getSystemClassLoader();
-        Assert.assertNotNull(systemClassLoader);
+        assertNotNull(systemClassLoader);
     }
 
     @Test
     public void testAgentClassLoader() throws ClassNotFoundException {
         ClassLoader agentClassLoader = classloaderService.getAgentClassLoader();
-        Assert.assertNotNull(agentClassLoader);
-        Assert.assertTrue(((URLClassLoader) agentClassLoader).getURLs().length == 2);
-        Assert.assertNotNull(agentClassLoader.loadClass("SampleClass"));
+        assertNotNull(agentClassLoader);
+        assertTrue(((URLClassLoader) agentClassLoader).getURLs().length == 2);
+        assertNotNull(agentClassLoader.loadClass("SampleClass"));
     }
 
     @Test
     public void testIsDeniedImportClass() {
+
         Biz biz = new BizModel().setBizName("mockBiz").setBizVersion("1.0.0")
             .setDenyImportPackages("a.c, a.b.c.*, a.b.c").setDenyImportClasses("")
-            .setBizState(BizState.RESOLVED);
+            .setBizState(RESOLVED);
         bizManagerService.registerBiz(biz);
-        AssertUtils.isFalse(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.c"),
-            "Exception error");
+        isFalse(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.c"), "Exception error");
 
-        AssertUtils.isTrue(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.c.E"),
+        isTrue(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.c.E"),
             "Exception error");
-        AssertUtils.isFalse(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.c.e.G"),
+        isFalse(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.c.e.G"),
             "Exception error");
-
-        AssertUtils.isTrue(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.b.c.E"),
+        isTrue(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.b.c.E"),
             "Exception error");
-        AssertUtils.isTrue(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.b.c.e.G"),
+        isTrue(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.b.c.e.G"),
             "Exception error");
-        AssertUtils.isFalse(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.b.c"),
+        isFalse(classloaderService.isDeniedImportClass(biz.getIdentity(), "a.b.c"),
             "Exception error");
     }
 
     @Test
     public void testIsClassImport() {
+
         Plugin plugin = new PluginModel().setPluginName("mockPlugin").setImportClasses(null)
             .setImportPackages("a.c,a.b.c.*,a.b.c");
         pluginManagerService.registerPlugin(plugin);
 
-        Assert.assertTrue(classloaderService.isClassInImport("mockPlugin", "a.c.e"));
-        Assert.assertFalse(classloaderService.isClassInImport("mockPlugin", "a.c"));
-        Assert.assertFalse(classloaderService.isClassInImport("mockPlugin", "a.c.e.f"));
-
-        Assert.assertFalse(classloaderService.isClassInImport("mockPlugin", "a.b.c"));
-        Assert.assertTrue(classloaderService.isClassInImport("mockPlugin", "a.b.c.e"));
-        Assert.assertTrue(classloaderService.isClassInImport("mockPlugin", "a.b.c.e.f"));
+        assertTrue(classloaderService.isClassInImport("mockPlugin", "a.c.e"));
+        assertFalse(classloaderService.isClassInImport("mockPlugin", "a.c"));
+        assertFalse(classloaderService.isClassInImport("mockPlugin", "a.c.e.f"));
+        assertFalse(classloaderService.isClassInImport("mockPlugin", "a.b.c"));
+        assertTrue(classloaderService.isClassInImport("mockPlugin", "a.b.c.e"));
+        assertTrue(classloaderService.isClassInImport("mockPlugin", "a.b.c.e.f"));
     }
 
     @Test
     public void testFindExportClass() {
+
         PluginClassLoader pluginClassLoader = new PluginClassLoader("mockPlugin", new URL[] {});
         Plugin plugin = new PluginModel().setPluginName("mockPlugin")
             .setExportPackages("a.b.*,a.f,a.b.f").setExportClasses("a.e.f.G")
             .setPluginClassLoader(pluginClassLoader).setExportResources("");
+
         pluginManagerService.registerPlugin(plugin);
         classloaderService.prepareExportClassAndResourceCache();
-        Assert.assertNull(classloaderService.findExportClassLoader("a.b"));
-        Assert.assertTrue(pluginClassLoader.equals(classloaderService
-            .findExportClassLoader("a.b.e.f")));
-        Assert.assertTrue(pluginClassLoader.equals(classloaderService
-            .findExportClassLoader("a.f.g")));
-        Assert.assertTrue(pluginClassLoader.equals(classloaderService
-            .findExportClassLoader("a.e.f.G")));
-        Assert.assertTrue(pluginClassLoader.equals(classloaderService
-            .findExportClassLoader("a.b.f.m")));
-        Assert.assertTrue(pluginClassLoader.equals(classloaderService
-            .findExportClassLoader("a.b.f.m.g")));
-        Assert.assertNull(classloaderService.findExportClassLoader("a.f.h.m"));
-        Assert.assertNull(classloaderService.findExportClassLoader("a"));
+        assertNull(classloaderService.findExportClassLoader("a.b"));
+        assertTrue(pluginClassLoader.equals(classloaderService.findExportClassLoader("a.b.e.f")));
+        assertTrue(pluginClassLoader.equals(classloaderService.findExportClassLoader("a.f.g")));
+        assertTrue(pluginClassLoader.equals(classloaderService.findExportClassLoader("a.e.f.G")));
+        assertTrue(pluginClassLoader.equals(classloaderService.findExportClassLoader("a.b.f.m")));
+        assertTrue(pluginClassLoader.equals(classloaderService.findExportClassLoader("a.b.f.m.g")));
+        assertNull(classloaderService.findExportClassLoader("a.f.h.m"));
+        assertNull(classloaderService.findExportClassLoader("a"));
         pluginManagerService.getPluginsInOrder().remove(plugin);
     }
 
     @Test
     public void testFindExportResources() {
+
         PluginClassLoader pluginClassLoader = new PluginClassLoader("mockPlugin", new URL[] {});
         String exportResources = "spring-beans.xsd,*.xsd,com/alipay/sofa/*,xml-test.xml";
         Plugin plugin = new PluginModel().setPluginName("mockPlugin").setExportPackages("")
@@ -187,18 +187,34 @@ public void testFindExportResources() {
         classloaderService.prepareExportClassAndResourceCache();
 
         Set<String> exportPrefixResourceStems = plugin.getExportPrefixResourceStems();
-        Assert.assertTrue(exportPrefixResourceStems.contains("com/alipay/sofa/"));
+        assertTrue(exportPrefixResourceStems.contains("com/alipay/sofa/"));
 
         Set<String> exportSuffixResourceStems = plugin.getExportSuffixResourceStems();
-        Assert.assertTrue(exportSuffixResourceStems.contains(".xsd"));
+        assertTrue(exportSuffixResourceStems.contains(".xsd"));
 
         Set<String> resources = plugin.getExportResources();
-        Assert.assertTrue(resources.contains("xml-test.xml"));
-        Assert.assertTrue(resources.contains("spring-beans.xsd"));
+        assertTrue(resources.contains("xml-test.xml"));
+        assertTrue(resources.contains("spring-beans.xsd"));
 
         plugin.getExportPrefixResourceStems().clear();
         plugin.getExportSuffixResourceStems().clear();
         plugin.getExportResources().clear();
         pluginManagerService.getPluginsInOrder().remove(plugin);
     }
-}
+
+    @Test
+    public void testFindExportResourceClassLoadersInOrder() throws Exception {
+
+        Field field = ClassLoaderServiceImpl.class
+            .getDeclaredField("exportSuffixStemResourceAndClassLoaderMap");
+        field.setAccessible(true);
+        ConcurrentHashMap exportPrefixStemResourceAndClassLoaderMap = new ConcurrentHashMap<>();
+        Plugin plugin = mock(Plugin.class);
+        exportPrefixStemResourceAndClassLoaderMap.put("myaaa", asList(plugin));
+        field.set(classloaderService, exportPrefixStemResourceAndClassLoaderMap);
+        assertEquals(null, classloaderService.findExportResourceClassLoadersInOrder("myaaa").get(0));
+
+        assertNull(classloaderService.getBizClassLoader("aaa:1.0"));
+        assertNull(classloaderService.getPluginClassLoader("aaa:2.0"));
+    }
+}