Test classes

test/res/bluej-project/Attractor.java

@@ -0,0 +1,29 @@
+
+import schule.ngb.zm.*;
+
+public class Attractor extends Mover {
+
+    private static final int G = 10;
+
+    private int mass = 0;
+
+    public Attractor( int x, int pY, int pMass ) {
+        this(x, pY, pMass, new Vector());
+    }
+
+    public Attractor( int x, int pY, int pMass, Vector pVelocity ) {
+        super(x, pY, pVelocity);
+        mass = pMass;
+
+        setFillColor(YELLOW);
+    }
+
+    public void attract( Mover pMover ) {
+        if( pMover != this ) {
+            Vector force = new Vector(this.x, this.y);
+            force.sub(pMover.getX(), pMover.getY()).scale(mass*G).limit(0, 50*G);
+            pMover.applyForce(force);
+        }
+    }
+
+}

test/res/bluej-project/BluejTest.java

@@ -0,0 +1,34 @@
+
+import schule.ngb.zm.Zeichenmaschine;
+
+import java.util.List;
+
+/**
+ * Beschreiben Sie hier die Klasse BluejTest.
+ *
+ * @author (Ihr Name)
+ * @version (eine Versionsnummer oder ein Datum)
+ */
+public class BluejTest extends Zeichenmaschine
+{
+    public void setup() {
+        if( !IN_BLUEJ ) {
+            drawing.clear(schule.ngb.zm.Color.HGRED);
+        } else {
+            drawing.clear(schule.ngb.zm.Color.HGGREEN);
+            
+        }
+    }
+
+    public void listClasses() {
+        // find all classes in classpath
+        List<String> allClasses = ClasspathInspector.getAllKnownClassNames();
+        System.out.printf("There are %s classes available in the classpath\n", allClasses.size());
+
+        for (String clazz : allClasses) {
+            if( clazz.contains("Boot") || clazz.contains("Main") ) {
+                System.out.printf("%s\n", clazz);
+            }
+        }
+    }
+}

test/res/bluej-project/ClasspathInspector.java

@@ -0,0 +1,283 @@
+
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.Serializable;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+/**
+ * Find classes in the classpath (reads JARs and classpath folders).
+ *
+ * @author Pål Brattberg, brattberg@gmail.com
+ * @see http://gist.github.com/pal
+ */
+@SuppressWarnings("unchecked")
+public class ClasspathInspector {
+    static boolean DEBUG = false;
+
+
+    public static List<String> getAllKnownClassNames() {
+        List<String> classNames = new ArrayList<String>();
+        List<File> classLocations = getClassLocationsForCurrentClasspath();
+        for (File file : classLocations) {
+            classNames.addAll(getClassNamesFromPath(file));
+        }
+        return classNames;
+    }
+
+    public static List<Class> getAllKnownClasses() {
+        List<Class> classFiles = new ArrayList<Class>();
+        List<File> classLocations = getClassLocationsForCurrentClasspath();
+        for (File file : classLocations) {
+            classFiles.addAll(getClassesFromPath(file));
+        }
+        return classFiles;
+    }
+
+    public static List<Class> getMatchingClasses(Class interfaceOrSuperclass) {
+        List<Class> matchingClasses = new ArrayList<Class>();
+        List<Class> classes = getAllKnownClasses();
+        log("checking %s classes", classes.size());
+        for (Class clazz : classes) {
+            if (interfaceOrSuperclass.isAssignableFrom(clazz)) {
+                matchingClasses.add(clazz);
+                log("class %s is assignable from %s", interfaceOrSuperclass, clazz);
+            }
+        }
+        return matchingClasses;
+    }
+
+    public static List<Class> getMatchingClasses(String validPackagePrefix, Class interfaceOrSuperclass) {
+        throw new IllegalStateException("Not yet implemented!");
+    }
+
+    public static List<Class> getMatchingClasses(String validPackagePrefix) {
+        throw new IllegalStateException("Not yet implemented!");
+    }
+
+    private static Collection<? extends Class> getClassesFromPath(File path) {
+        if (path.isDirectory()) {
+            return getClassesFromDirectory(path);
+        } else {
+            return getClassesFromJarFile(path);
+        }
+    }
+
+    private static Collection<String> getClassNamesFromPath(File path) {
+        if (path.isDirectory()) {
+            return getClassNamesFromDirectory(path);
+        } else {
+            return getClassNamesFromJarFile(path);
+        }
+    }
+
+    private static String fromFileToClassName(final String fileName) {
+        return fileName.substring(0, fileName.length() - 6).replaceAll("/|\\\\", "\\.");
+    }
+
+    private static List<Class> getClassesFromJarFile(File path) {
+        List<Class> classes = new ArrayList<Class>();
+        log("getClassesFromJarFile: Getting classes for " + path);
+
+        try {
+            if (path.canRead()) {
+                JarFile jar = new JarFile(path);
+                Enumeration<JarEntry> en = jar.entries();
+                while (en.hasMoreElements()) {
+                    JarEntry entry = en.nextElement();
+                    if (entry.getName().endsWith("class")) {
+                        String className = fromFileToClassName(entry.getName());
+                        log("\tgetClassesFromJarFile: found " + className);
+                        Class claz = Class.forName(className);
+                        classes.add(claz);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to read classes from jar file: " + path, e);
+        }
+
+        return classes;
+    }
+
+    private static List<String> getClassNamesFromJarFile(File path) {
+        List<String> classes = new ArrayList<>();
+        log("getClassNamesFromJarFile: Getting classes for " + path);
+
+        try {
+            if (path.canRead()) {
+                JarFile jar = new JarFile(path);
+                Enumeration<JarEntry> en = jar.entries();
+                while (en.hasMoreElements()) {
+                    JarEntry entry = en.nextElement();
+                    if (entry.getName().endsWith("class")) {
+                        String className = fromFileToClassName(entry.getName());
+                        classes.add(className);
+                        log("\tgetClassesFromJarFile: found " + className);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to read classnames from jar file: " + path, e);
+        }
+
+        return classes;
+    }
+
+    private static List<Class> getClassesFromDirectory(File path) {
+        List<Class> classes = new ArrayList<Class>();
+        log("getClassesFromDirectory: Getting classes for " + path);
+
+        // get jar files from top-level directory
+        List<File> jarFiles = listFiles(path, new FilenameFilter() {
+            @Override
+            public boolean accept(File dir, String name) {
+                return name.endsWith(".jar");
+            }
+        }, false);
+        for (File file : jarFiles) {
+            classes.addAll(getClassesFromJarFile(file));
+        }
+
+        // get all class-files
+        List<File> classFiles = listFiles(path, new FilenameFilter() {
+            @Override
+            public boolean accept(File dir, String name) {
+                return name.endsWith(".class");
+            }
+        }, true);
+
+        // List<URL> urlList = new ArrayList<URL>();
+        // List<String> classNameList = new ArrayList<String>();
+        int substringBeginIndex = path.getAbsolutePath().length() + 1;
+        for (File classfile : classFiles) {
+            String className = classfile.getAbsolutePath().substring(substringBeginIndex);
+            className = fromFileToClassName(className);
+            log("Found class %s in path %s: ", className, path);
+            try {
+                classes.add(Class.forName(className));
+            } catch (Throwable e) {
+                log("Couldn't create class %s. %s: ", className, e);
+            }
+
+        }
+
+        return classes;
+    }
+
+    private static List<String> getClassNamesFromDirectory(File path) {
+        List<String> classes = new ArrayList<>();
+        log("getClassNamesFromDirectory: Getting classes for " + path);
+
+        // get jar files from top-level directory
+        List<File> jarFiles = listFiles(path, new FilenameFilter() {
+            @Override
+            public boolean accept(File dir, String name) {
+                return name.endsWith(".jar");
+            }
+        }, false);
+        for (File file : jarFiles) {
+            classes.addAll(getClassNamesFromJarFile(file));
+        }
+
+        // get all class-files
+        List<File> classFiles = listFiles(path, new FilenameFilter() {
+            @Override
+            public boolean accept(File dir, String name) {
+                return name.endsWith(".class");
+            }
+        }, true);
+
+        // List<URL> urlList = new ArrayList<URL>();
+        // List<String> classNameList = new ArrayList<String>();
+        int substringBeginIndex = path.getAbsolutePath().length() + 1;
+        for (File classfile : classFiles) {
+            String className = classfile.getAbsolutePath().substring(substringBeginIndex);
+            className = fromFileToClassName(className);
+            log("Found class %s in path %s: ", className, path);
+            classes.add(className);
+        }
+
+        return classes;
+    }
+
+    private static List<File> listFiles(File directory, FilenameFilter filter, boolean recurse) {
+        List<File> files = new ArrayList<File>();
+        File[] entries = directory.listFiles();
+
+        // Go over entries
+        for (File entry : entries) {
+            // If there is no filter or the filter accepts the
+            // file / directory, add it to the list
+            if (filter == null || filter.accept(directory, entry.getName())) {
+                files.add(entry);
+            }
+
+            // If the file is a directory and the recurse flag
+            // is set, recurse into the directory
+            if (recurse && entry.isDirectory()) {
+                files.addAll(listFiles(entry, filter, recurse));
+            }
+        }
+
+        // Return collection of files
+        return files;
+    }
+
+    public static List<File> getClassLocationsForCurrentClasspath() {
+        List<File> urls = new ArrayList<File>();
+        String javaClassPath = System.getProperty("java.class.path");
+        if (javaClassPath != null) {
+            for (String path : javaClassPath.split(File.pathSeparator)) {
+                urls.add(new File(path));
+            }
+        }
+        return urls;
+    }
+
+    // todo: this is only partial, probably
+    public static URL normalize(URL url) throws MalformedURLException {
+        String spec = url.getFile();
+
+        // get url base - remove everything after ".jar!/??" , if exists
+        final int i = spec.indexOf("!/");
+        if (i != -1) {
+            spec = spec.substring(0, spec.indexOf("!/"));
+        }
+
+        // uppercase windows drive
+        url = new URL(url, spec);
+        final String file = url.getFile();
+        final int i1 = file.indexOf(':');
+        if (i1 != -1) {
+            String drive = file.substring(i1 - 1, 2).toUpperCase();
+            url = new URL(url, file.substring(0, i1 - 1) + drive + file.substring(i1));
+        }
+
+        return url;
+    }
+
+    private static void log(String pattern, final Object... args) {
+        if (DEBUG)
+            System.out.printf(pattern + "\n", args);
+    }
+
+    public static void main(String[] args) {
+        // find all classes in classpath
+        List<Class> allClasses = ClasspathInspector.getAllKnownClasses();
+        System.out.printf("There are %s classes available in the classpath\n", allClasses.size());
+
+        // find all classes that implement/subclass an interface/superclass
+        List<Class> serializableClasses = ClasspathInspector.getMatchingClasses(Serializable.class);
+        for (Class clazz : serializableClasses) {
+            System.out.printf("%s is Serializable\n", clazz);
+        }
+    }
+}

test/res/bluej-project/Gravity.java

@@ -0,0 +1,40 @@
+
+import java.util.LinkedList;
+
+import schule.ngb.zm.*;
+
+public class Gravity extends Zeichenmaschine {
+    
+    private LinkedList<Mover> movers = new LinkedList<>();
+    
+    private LinkedList<Attractor> attractors = new LinkedList<>();
+    
+    public void setup(){
+         for( int i = 0; i < 10; i++ ) {
+             Mover m = new Mover(random(10, width-10), random(10, height-10));
+             movers.add(m);
+             shapes.add(m);
+         }
+         
+         attractors.add(new Attractor(width/2, height/2, 10));
+         shapes.add(attractors.get(0));
+    }
+    
+    public void update( double delta ) {
+        for( Attractor a: attractors ) {
+            for( Mover m: movers ) {
+                a.attract(m);
+            }
+        }
+        
+        for( Mover m: movers ) {
+            m.update(delta);
+        }
+        shapes.clear();
+    }
+    
+    public void draw() {
+        shapes.clear();
+    }
+    
+}

test/res/bluej-project/Mover.java

@@ -0,0 +1,38 @@
+
+import schule.ngb.zm.*;
+import schule.ngb.zm.formen.*;
+
+public class Mover extends Circle implements Updatable {
+
+    private Vector velocity;
+    private Vector acceleration = new Vector();
+
+    public Mover( int x, int pY ) {
+        this(x, pY, new Vector());
+    }
+
+    public Mover( int x, int pY, Vector pVelocity ) {
+        super(x, pY, 10);
+        this.velocity = pVelocity.copy();
+    }
+
+    public void applyForce( Vector force ) {
+        acceleration.add(force);
+    }
+
+    public boolean isActive() {
+        return true;
+    }
+
+    public void update( double delta ) {
+        acceleration.scale(delta);
+        velocity.add(acceleration);
+        acceleration.scale(0.0);
+
+        this.x += velocity.x;
+        this.y += velocity.y;
+
+
+    }
+
+}

test/res/bluej-project/package.bluej

@@ -0,0 +1,69 @@
+#BlueJ package file
+dependency1.from=BluejTest
+dependency1.to=ClasspathInspector
+dependency1.type=UsesDependency
+dependency2.from=Gravity
+dependency2.to=Mover
+dependency2.type=UsesDependency
+dependency3.from=Gravity
+dependency3.to=Attractor
+dependency3.type=UsesDependency
+editor.fx.0.height=728
+editor.fx.0.width=1037
+editor.fx.0.x=95
+editor.fx.0.y=53
+objectbench.height=94
+objectbench.width=776
+package.divider.horizontal=0.6
+package.divider.vertical=0.8305369127516778
+package.editor.height=488
+package.editor.width=661
+package.editor.x=374
+package.editor.y=158
+package.frame.height=660
+package.frame.width=800
+package.numDependencies=3
+package.numTargets=5
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=60
+readme.name=@README
+readme.width=48
+readme.x=10
+readme.y=10
+target1.height=70
+target1.name=Mover
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=120
+target1.x=320
+target1.y=200
+target2.height=70
+target2.name=BluejTest
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=120
+target2.x=70
+target2.y=10
+target3.height=70
+target3.name=Attractor
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=120
+target3.x=390
+target3.y=350
+target4.height=70
+target4.name=ClasspathInspector
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=130
+target4.x=380
+target4.y=30
+target5.height=70
+target5.name=Gravity
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=120
+target5.x=100
+target5.y=300