1 files changed, 218 insertions, 0 deletions
diff --git a/src/junit/com/jogamp/common/util/TestTempJarCache.java b/src/junit/com/jogamp/common/util/TestTempJarCache.java
new file mode 100644
index 0000000..a0e0379
--- /dev/null
+++ b/src/junit/com/jogamp/common/util/TestTempJarCache.java
@@ -0,0 +1,218 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+ 
+package com.jogamp.common.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.jar.JarFile;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.jogamp.common.GlueGenVersion;
+import com.jogamp.common.os.NativeLibrary;
+import com.jogamp.common.os.Platform;
+import com.jogamp.common.util.cache.TempFileCache;
+import com.jogamp.common.util.cache.TempJarCache;
+
+public class TestTempJarCache {
+    static TempFileCache fileCache;
+    
+    static class TestClassLoader extends URLClassLoader {
+        public TestClassLoader(URL[] urls) {
+            super(urls);
+        }
+        public TestClassLoader(URL[] urls, ClassLoader parent) {
+            super(urls, parent);
+        }
+    }
+    
+    static void assertTempFileCachesIndividualInstances(boolean shallBeSame, TempFileCache fileCache2, TempFileCache fileCache3) {
+        Assert.assertTrue(fileCache2.getTempDir().exists());
+        Assert.assertTrue(fileCache2.getTempDir().isDirectory());
+        Assert.assertTrue(fileCache3.getTempDir().exists());
+        Assert.assertTrue(fileCache3.getTempDir().isDirectory());
+        
+        Assert.assertEquals(fileCache2.getBaseDir(), fileCache3.getBaseDir());
+        Assert.assertEquals(fileCache2.getRootDir(), fileCache3.getRootDir());
+        
+        if(shallBeSame) {
+            Assert.assertTrue("file caches are not equal", fileCache2.getTempDir().equals(fileCache3.getTempDir()));        
+        } else {
+            Assert.assertFalse("file caches are equal", fileCache2.getTempDir().equals(fileCache3.getTempDir()));        
+        }
+        // also verify with diff classloader/reflection method, 
+        // to proof that methodology is valid!
+        ClassLoader cl = fileCache2.getClass().getClassLoader();
+        assertTempFileCachesIndividualInstances(shallBeSame, fileCache2, cl, fileCache3, cl);
+    }
+    
+    static void assertTempFileCachesIndividualInstances(boolean shallBeSame, Object fileCache2, ClassLoader cl2, Object fileCache3, ClassLoader cl3) {
+        Class<?> fileCacheClazz2 = ReflectionUtil.getClass(TempFileCache.class.getName(), false, cl2);
+        Class<?> fileCacheClazz3 = ReflectionUtil.getClass(TempFileCache.class.getName(), false, cl3);
+
+        Method fc2GetBaseDir = ReflectionUtil.getMethod(fileCacheClazz2 , "getBaseDir");
+        Method fc3GetBaseDir = ReflectionUtil.getMethod(fileCacheClazz3 , "getBaseDir");        
+        Object baseDir2 = ReflectionUtil.callMethod(fileCache2, fc2GetBaseDir);
+        Object baseDir3 = ReflectionUtil.callMethod(fileCache3, fc3GetBaseDir);
+        Assert.assertEquals(baseDir2, baseDir3);
+        
+        Method fc2GetRootDir = ReflectionUtil.getMethod(fileCacheClazz2 , "getRootDir");
+        Method fc3GetRootDir = ReflectionUtil.getMethod(fileCacheClazz3 , "getRootDir");        
+        Object rootDir2 = ReflectionUtil.callMethod(fileCache2, fc2GetRootDir);
+        Object rootDir3 = ReflectionUtil.callMethod(fileCache3, fc3GetRootDir);
+        Assert.assertEquals(rootDir2, rootDir3);
+        
+        Method fc2GetTempDir = ReflectionUtil.getMethod(fileCacheClazz2 , "getTempDir");
+        Method fc3GetTempDir = ReflectionUtil.getMethod(fileCacheClazz3 , "getTempDir");        
+        Object tempDir2 = ReflectionUtil.callMethod(fileCache2, fc2GetTempDir);
+        Object tempDir3 = ReflectionUtil.callMethod(fileCache3, fc3GetTempDir);
+        
+        if(shallBeSame) {
+            Assert.assertTrue("file caches are not equal", tempDir2.equals(tempDir3));
+        } else {
+            Assert.assertFalse("file caches are equal", tempDir2.equals(tempDir3));
+        }
+    }
+    
+    @BeforeClass
+    public static void init() {
+        fileCache = new TempFileCache();
+        Assert.assertTrue(fileCache.isValid());
+        System.err.println("tmp dir: "+fileCache.getTempDir());
+        
+    }
+    
+    @Test
+    public void testTempFileCache01FileExist() throws IOException {
+        Assert.assertTrue(fileCache.getTempDir().exists());
+        Assert.assertTrue(fileCache.getTempDir().isDirectory());
+    }
+    
+    @Test
+    public void testTempFileCache02Instances() throws IOException {        
+        TempFileCache fileCache2 = new TempFileCache();
+        TempFileCache fileCache3 = new TempFileCache();
+        
+        assertTempFileCachesIndividualInstances(false, fileCache2, fileCache3);
+    }
+    
+    @Test
+    public void testJarUtil01a() throws IOException {
+        JarFile jarFile = JarUtil.getJarFile(GlueGenVersion.class.getName(), this.getClass().getClassLoader());
+        Assert.assertNotNull("jarFile: "+jarFile);
+        JarUtil.extract(fileCache.getTempDir(), null, jarFile, false, true, true);
+        File f = new File(fileCache.getTempDir(), "META-INF/MANIFEST.MF");
+        Assert.assertTrue(f.exists());
+        f = new File(fileCache.getTempDir(), IOUtil.getClassFileName(GlueGenVersion.class.getName()));
+        Assert.assertTrue(f.exists());
+    }
+
+    @Test
+    public void testJarUtil01b() throws IOException {        
+        File f = new File(fileCache.getTempDir(), "META-INF/MANIFEST.MF");
+        Assert.assertTrue(f.exists());
+        f = new File(fileCache.getTempDir(), IOUtil.getClassFileName(GlueGenVersion.class.getName()));
+        Assert.assertTrue(f.exists());
+    }
+    
+    @Test
+    public void testTempJarCache01LoadAllTestManifestAndClass() throws IOException {
+        Assert.assertTrue(TempJarCache.isValid());
+        TempJarCache.addAll(JarUtil.getJarFile(GlueGenVersion.class.getName(), getClass().getClassLoader()));
+        
+        File f0 = new File(TempJarCache.getTempFileCache().getTempDir(), "META-INF/MANIFEST.MF");
+        Assert.assertTrue(f0.exists());
+        
+        File f1 = new File(TempJarCache.findResource("META-INF/MANIFEST.MF"));
+        Assert.assertTrue(f1.exists());
+        Assert.assertEquals(f0, f1);
+
+        f0 = new File(TempJarCache.getTempFileCache().getTempDir(), IOUtil.getClassFileName(GlueGenVersion.class.getName()));
+        Assert.assertTrue(f0.exists());
+        
+        f1 = new File(TempJarCache.findResource(IOUtil.getClassFileName(GlueGenVersion.class.getName())));
+        Assert.assertTrue(f1.exists());
+        Assert.assertEquals(f0, f1);
+    }
+    
+    @Test
+    public void testTempJarCache02LoadNativeLibrary() throws IOException {
+        final String nativeJarName = "gluegen-rt-natives-"+Platform.getOSAndArch()+".jar";
+        final String libBaseName = "gluegen-rt";        
+        final ClassLoader cl = getClass().getClassLoader();
+        
+        URL jarUrlRoot = JarUtil.getJarURL(TempJarCache.class.getName(), cl);
+        jarUrlRoot = JarUtil.getJarURLDirname(jarUrlRoot);
+        
+        URL nativeJarURL = JarUtil.getJarURL(jarUrlRoot, nativeJarName);        
+        JarFile nativeJar = JarUtil.getJarFile(nativeJarURL, cl);
+        
+        TempJarCache.addNativeLibs(nativeJar);
+        String libFullPath = TempJarCache.findLibrary(libBaseName);
+        Assert.assertNotNull(libFullPath);
+        Assert.assertEquals(libBaseName, NativeLibrary.isValidNativeLibraryName(libFullPath, true));
+        File f = new File(libFullPath);
+        Assert.assertTrue(f.exists());
+    }
+    
+    @Test
+    public void testTempJarCache04aSameClassLoader() throws IOException {        
+        assertTempFileCachesIndividualInstances(true, TempJarCache.getTempFileCache(), TempJarCache.getTempFileCache());
+        
+        ClassLoader cl = getClass().getClassLoader();          
+        TempFileCache fileCache2 = (TempFileCache) ReflectionUtil.callStaticMethod(TempJarCache.class.getName(), "getTempFileCache", null, null, cl);
+        TempFileCache fileCache3 = (TempFileCache) ReflectionUtil.callStaticMethod(TempJarCache.class.getName(), "getTempFileCache", null, null, cl);
+        assertTempFileCachesIndividualInstances(true, fileCache2, fileCache3);
+    }
+    
+    @Test
+    public void testTempJarCache04bDiffClassLoader() throws IOException {
+        URL[] urls = new URL[] { JarUtil.getJarURL(TempJarCache.class.getName(), getClass().getClassLoader()) };                
+        System.err.println("url: "+urls[0]);
+        ClassLoader cl2 = new TestClassLoader(urls, null);  
+        ClassLoader cl3 = new TestClassLoader(urls, null);
+        
+        Object fileCache2 = ReflectionUtil.callStaticMethod(TempJarCache.class.getName(), "getTempFileCache", null, null, cl2);
+        Object fileCache3 = ReflectionUtil.callStaticMethod(TempJarCache.class.getName(), "getTempFileCache", null, null, cl3);
+
+        assertTempFileCachesIndividualInstances(false, fileCache2, cl2, fileCache3, cl3);
+    }
+    
+    public static void main(String args[]) throws IOException {
+        String tstname = TestTempJarCache.class.getName();
+        org.junit.runner.JUnitCore.main(tstname);
+    }
+
+}