harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ndbe...@apache.org
Subject svn commit: r479469 - in /harmony/enhanced/classlib/trunk/modules/swing: .classpath build.xml src/test/api/java/common/javax/swing/BasicSwingTestCase.java src/test/api/java/common/javax/swing/SwingTestCase.java
Date Mon, 27 Nov 2006 00:07:05 GMT
Author: ndbeyer
Date: Sun Nov 26 16:07:04 2006
New Revision: 479469

URL: http://svn.apache.org/viewvc?view=rev&rev=479469
Log:
Move base Swing test case classes from 'support' to 'swing', modify test run in 'build.xml'
to avoid running the new base classes.

Added:
    harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/BasicSwingTestCase.java
  (with props)
    harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/SwingTestCase.java
  (with props)
Modified:
    harmony/enhanced/classlib/trunk/modules/swing/.classpath
    harmony/enhanced/classlib/trunk/modules/swing/build.xml

Modified: harmony/enhanced/classlib/trunk/modules/swing/.classpath
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/swing/.classpath?view=diff&rev=479469&r1=479468&r2=479469
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/swing/.classpath (original)
+++ harmony/enhanced/classlib/trunk/modules/swing/.classpath Sun Nov 26 16:07:04 2006
@@ -1,13 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry output="bin/main/common" kind="src" path="src/main/java/common"/>
-	<classpathentry output="bin/main/windows" kind="src" path="src/main/java/windows"/>
-	<classpathentry output="bin/main/linux" kind="src" path="src/main/java/linux"/>
-	<classpathentry output="bin/test/java" kind="src" path="src/test/java"/>
-	<classpathentry output="bin/test/api" kind="src" path="src/test/api/java/common"/>
-	<classpathentry output="bin/test/injected" kind="src" path="src/test/api/java.injected"/>
+	<classpathentry kind="src" output="bin/main/common" path="src/main/java/common"/>
+	<classpathentry kind="src" output="bin/main/windows" path="src/main/java/windows"/>
+	<classpathentry kind="src" output="bin/main/linux" path="src/main/java/linux"/>
+	<classpathentry kind="src" output="bin/test/api" path="src/test/api/java/common"/>
+	<classpathentry kind="src" output="bin/test/injected" path="src/test/api/java.injected"/>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry sourcepath="JUNIT_SRC_HOME/junitsrc.zip" kind="var" path="JUNIT_HOME/junit.jar"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/support"/>
+	<classpathentry kind="var" path="JUNIT_HOME/junit.jar" sourcepath="JUNIT_SRC_HOME/junitsrc.zip"/>
 	<classpathentry kind="output" path=""/>
 </classpath>

Modified: harmony/enhanced/classlib/trunk/modules/swing/build.xml
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/swing/build.xml?view=diff&rev=479469&r1=479468&r2=479469
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/swing/build.xml (original)
+++ harmony/enhanced/classlib/trunk/modules/swing/build.xml Sun Nov 26 16:07:04 2006
@@ -185,7 +185,7 @@
                 unless="test.case">
 
                 <fileset dir="${hy.swing.src.test.api}/java/common">
-                    <include name="**/*Test*.java"/>
+                    <include name="**/*Test.java"/>
                     <excludesfile name="${exclude.file}" />
                 </fileset>
             </batchtest>

Added: harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/BasicSwingTestCase.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/BasicSwingTestCase.java?view=auto&rev=479469
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/BasicSwingTestCase.java
(added)
+++ harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/BasicSwingTestCase.java
Sun Nov 26 16:07:04 2006
@@ -0,0 +1,650 @@
+/*
+ *  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.
+ */
+
+/**
+ * @author Anton Avtamonov
+ * @version $Revision$
+ */
+package javax.swing;
+
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Frame;
+import java.awt.Graphics;
+import java.awt.Robot;
+import java.awt.Toolkit;
+import java.awt.image.BufferedImage;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.EventListener;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.text.BadLocationException;
+
+import junit.framework.TestCase;
+
+public abstract class BasicSwingTestCase extends TestCase {
+    public static final long DEFAULT_TIMEOUT_DELAY = 10000;
+
+    private boolean ignoreNotImplemented;
+    private Robot robot;
+    private LookAndFeel previousLF;
+
+    private static long defaultTimeoutDelay;
+    protected static long timeoutDelay = defaultTimeoutDelay;
+
+    static {
+        String timeoutProp = System.getProperty("test.timeout");
+        if (timeoutProp == null || timeoutProp.length() == 0) {
+            defaultTimeoutDelay = DEFAULT_TIMEOUT_DELAY;
+        } else {
+            defaultTimeoutDelay = Integer.parseInt(timeoutProp);
+        }
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        timeoutDelay = defaultTimeoutDelay;
+        previousLF = UIManager.getLookAndFeel();
+        super.setUp();
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        UIManager.getDefaults().clear();
+        if (previousLF != null) {
+            UIManager.setLookAndFeel(previousLF);
+        } else {
+            UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
+        }
+        JFrame.setDefaultLookAndFeelDecorated(false);
+        JDialog.setDefaultLookAndFeelDecorated(false);
+        closeAllFrames();
+    }
+
+    public static void assertEquals(final Object[] expected, final Object[] actual) {
+        if (expected == null && actual == null) {
+            return;
+        }
+        if (expected == null || actual == null) {
+            fail("Arrays are not same: one of them is null");
+        }
+        assertEquals("Arrays of different types", expected.getClass(), actual.getClass());
+        assertEquals("Arrays of different lengths", expected.length, actual.length);
+        for (int i = 0; i < expected.length; i++) {
+            assertEquals("Arrays content at index " + i + " is not same", expected[i], actual[i]);
+        }
+    }
+
+
+
+    public BasicSwingTestCase() {
+    }
+
+    public BasicSwingTestCase(final String name) {
+        super(name);
+    }
+
+    protected void runBareSuper() throws Throwable {
+        super.runBare();
+    }
+
+    protected Throwable runBareImpl() throws Throwable {
+        try {
+            runBareSuper();
+        } catch (Throwable e) {
+            return e;
+        }
+
+        return null;
+    }
+
+    @Override
+    public void runBare() throws Throwable {
+        final Throwable[] exception = new Throwable[1];
+        Thread thread = new Thread(new Runnable() {
+            public void run() {
+                try {
+                    exception[0] = runBareImpl();
+                } catch (Throwable e) {
+                }
+            }
+        });
+        thread.start();
+        thread.join(timeoutDelay);
+        if (thread.isAlive()) {
+            // TODO is this stop necessary?
+            thread.stop();
+            fail("Test interrupted due timeout");
+        }
+        if (exception[0] != null) {
+            rethrow(exception[0]);
+        }
+    }
+
+    public void setIgnoreNotImplemented(final boolean b) {
+        ignoreNotImplemented = b;
+    }
+
+    protected static class Marker {
+        private final boolean autoreset;
+
+        private boolean occured;
+        private Object auxiliary;
+
+        public Marker() {
+            this(false);
+        }
+
+        /**
+         * If autoreset is turned on, then the call to <code>isOccurred()</code>
+         * resets the state just before returning the value.
+         *
+         * @param autoreset enables the autoreset feature
+         */
+        public Marker(final boolean autoreset) {
+            this.autoreset = autoreset;
+        }
+
+        public void setOccurred() {
+            setOccurred(true);
+        }
+
+        public void setOccurred(final boolean occured) {
+            this.occured = occured;
+        }
+
+        /**
+         * Returns the state of this marker. If autoreset feature is enabled,
+         * <code>reset()</code> method will be called before return. Beware that
+         * any auxiliary data will also be reset, if the feature is enabled.
+         *
+         * @return true if an event occurred
+         */
+        public boolean isOccurred() {
+            boolean result = occured;
+            if (autoreset) {
+                reset();
+            }
+            return result;
+        }
+
+        public void setAuxiliary(final Object aux) {
+            auxiliary = aux;
+        }
+
+        public Object getAuxiliary() {
+            return auxiliary;
+        }
+
+        public void reset() {
+            occured = false;
+            auxiliary = null;
+        }
+
+        public boolean isAutoreset() {
+            return autoreset;
+        }
+    }
+
+    private class FixedFontMetrics extends FontMetrics {
+        private static final long serialVersionUID = 1L;
+        private final int charWidth;
+        private final int charHeight;
+
+        public FixedFontMetrics(final Font fnt, final int charWidth) {
+            super(fnt);
+            this.charWidth = charWidth;
+            charHeight = super.getHeight();
+        }
+
+        public FixedFontMetrics(final Font fnt, final int charWidth, final int charHeight)
{
+            super(fnt);
+            this.charWidth = charWidth;
+            this.charHeight = charHeight;
+        }
+
+        @Override
+        public int stringWidth(final String str) {
+            return ((str == null || str.equals("")) ? 0 : str.length() * charWidth);
+        }
+
+        @Override
+        public int charWidth(final int ch) {
+            return charWidth;
+        }
+
+        @Override
+        public int charWidth(final char ch) {
+            return charWidth;
+        }
+
+        @Override
+        public int getAscent() {
+            return charWidth;
+        }
+
+        @Override
+        public int getDescent() {
+            return charWidth*2;
+        }
+
+        @Override
+        public int getLeading() {
+            return 2;
+        }
+
+        @Override
+        public int getHeight() {
+            return charHeight;
+        }
+    };
+
+    protected abstract class ExceptionalCase {
+        private Class<?> clazz;
+        private String msg;
+
+        public abstract void exceptionalAction() throws Exception;
+
+        public ExceptionalCase() {
+        }
+
+        public ExceptionalCase(String msg, Class<?> clazz) {
+            this.msg = msg;
+            this.clazz = clazz;
+        }
+
+        public Class<?> expectedExceptionClass() {
+            return clazz;
+        }
+
+        public String expectedExceptionMessage() {
+            return msg;
+        }
+    }
+
+    protected abstract class BadLocationCase extends ExceptionalCase {
+        @Override
+        public Class<?> expectedExceptionClass() {
+            return BadLocationException.class;
+        }
+    }
+
+    protected abstract class ClassCastCase extends ExceptionalCase {
+        @Override
+        public Class<?> expectedExceptionClass() {
+            return ClassCastException.class;
+        }
+    }
+
+    protected abstract class IllegalArgumentCase extends ExceptionalCase {
+        @Override
+        public Class<?> expectedExceptionClass() {
+            return IllegalArgumentException.class;
+        }
+    }
+
+    protected abstract class NullPointerCase extends ExceptionalCase {
+        @Override
+        public Class<?> expectedExceptionClass() {
+            return NullPointerException.class;
+        }
+    }
+
+    protected abstract class StringIndexOutOfBoundsCase extends ExceptionalCase {
+        @Override
+        public Class<?> expectedExceptionClass() {
+            return StringIndexOutOfBoundsException.class;
+        }
+    }
+
+    protected static class EventsController implements Serializable {
+        private static final long serialVersionUID = 1L;
+        private boolean isVerbose;
+        private Object lastEventHappened;
+        private final Map<Object, Object> events = new HashMap<Object, Object>();
+
+        protected EventsController() {
+            this(false);
+        }
+
+        protected EventsController(final boolean verbose) {
+            isVerbose = verbose;
+        }
+
+        public void setVerbose(final boolean verbose) {
+            isVerbose = verbose;
+        }
+
+        protected boolean isVerbose() {
+            return isVerbose;
+        }
+
+        public void reset() {
+            lastEventHappened = null;
+            events.clear();
+        }
+
+        public boolean isChanged() {
+            return events.size() != 0;
+        }
+
+        public boolean isChanged(final Object key) {
+            if (!isChanged() || key == null) {
+                return false;
+            }
+            for (Iterator<Object> it = events.keySet().iterator(); it.hasNext(); )
{
+                String property = (String)it.next();
+                if (key.equals(property)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        protected void addEvent(final Object key, final Object event) {
+            events.put(key, event);
+            lastEventHappened = event;
+        }
+
+        public Object getEvent(final Object key) {
+            return events.get(key);
+        }
+
+        public Object getLastEvent() {
+            return lastEventHappened;
+        }
+
+        public int getNumEvents() {
+            return events.size();
+        }
+
+        public int findMe(final Object[] listenersArray) {
+            int found = 0;
+            for (Object element : listenersArray) {
+                if (element == this) {
+                    found++;
+                }
+            }
+
+            return found;
+        }
+    }
+
+    protected class PropertyChangeController extends EventsController implements PropertyChangeListener
{
+        private static final long serialVersionUID = 1L;
+        public PropertyChangeController() {
+            super(false);
+        }
+
+        public PropertyChangeController(final boolean verbose) {
+            super(verbose);
+        }
+
+        public void propertyChange(final PropertyChangeEvent e) {
+            addEvent(e.getPropertyName(), e);
+            if (isVerbose()) {
+                System.out.println("Changed property " + e.getPropertyName() + ", old value
= '" + e.getOldValue() + "', new value = '" + e.getNewValue() + "'");
+            }
+        }
+
+        public void checkLastPropertyFired(final Object source, final String propertyName,
+                                        final Object oldValue, final Object newValue) {
+            PropertyChangeEvent lastEvent = (PropertyChangeEvent)getLastEvent();
+            checkEvent(lastEvent, source, propertyName, oldValue, newValue);
+        }
+
+        public void checkPropertyFired(final Object source, final String propertyName,
+                                       final Object oldValue, final Object newValue) {
+            PropertyChangeEvent e = (PropertyChangeEvent)getEvent(propertyName);
+            checkEvent(e, source, propertyName, oldValue, newValue);
+        }
+
+        private void checkEvent(PropertyChangeEvent event, final Object source,
+                               final String propertyName,
+                               final Object oldValue, final Object newValue) {
+               assertNotNull("event's been fired ", event);
+               assertEquals("event's property name ", propertyName, event.getPropertyName());
+               assertEquals("event's oldValue ", oldValue, event.getOldValue());
+               assertEquals("event's newValue ", newValue, event.getNewValue());
+               assertSame("event's source ", source, event.getSource());
+           }
+    }
+
+    protected class ChangeController extends EventsController implements ChangeListener {
+        private static final long serialVersionUID = 1L;
+
+        public ChangeController() {
+            super(false);
+        }
+
+        public ChangeController(final boolean verbose) {
+            super(verbose);
+        }
+
+        public void stateChanged(ChangeEvent e) {
+            addEvent(new Integer(getNumEvents()), e);
+            if (isVerbose()) {
+                System.out.println("Changed");
+            }
+        }
+
+        public ChangeEvent getEvent() {
+            return (ChangeEvent)getLastEvent();
+        }
+    }
+
+    protected interface TraverseAction {
+        void componentTraversed(Component c);
+    }
+
+
+    /**
+     * PropertyChangeListener for test purposes to easily check that some property was changed
+     */
+    protected PropertyChangeController propertyChangeController;
+
+    public static boolean isHarmony() {
+        return Toolkit.getDefaultToolkit().getClass().getName().equals("java.awt.ToolkitImpl");
+    }
+
+    /**
+     * Serializes an object and returns the deserialized version of this object.
+     *
+     * @param objectToWrite object to serialize
+     * @return the deserialized object if successful
+     * @throws IOException if write or read operation throws this exception.
+     * @throws ClassNotFoundException if object cannot be read
+     *                                from an input stream
+     */
+    public static Object serializeObject(final Object objectToWrite)
+        throws IOException, ClassNotFoundException {
+
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        ObjectOutputStream oos = new ObjectOutputStream(output);
+        oos.writeObject(objectToWrite);
+        oos.close();
+        output.close();
+
+        InputStream input = new ByteArrayInputStream(output.toByteArray());
+        ObjectInputStream ois = new ObjectInputStream(input);
+        Object result = ois.readObject();
+        ois.close();
+        input.close();
+
+        return result;
+    }
+
+    protected Graphics createTestGraphics() {
+        return new BufferedImage(300, 300, BufferedImage.TYPE_3BYTE_BGR).createGraphics();
+    }
+
+    protected FontMetrics getFontMetrics(final Font fnt) {
+        return new FixedFontMetrics(fnt, fnt.getSize());
+    }
+
+    protected FontMetrics getFontMetrics(final Font fnt, final int charWidth) {
+        return new FixedFontMetrics(fnt, charWidth);
+    }
+
+    protected FontMetrics getFontMetrics(final Font fnt, final int charWidth, final int charHeight)
{
+        return new FixedFontMetrics(fnt, charWidth, charHeight);
+    }
+
+    protected void testExceptionalCase(final ExceptionalCase ec) {
+        try {
+            ec.exceptionalAction();
+            fail("Exceptional case was not detected!");
+        } catch (final Exception e) {
+            if (ec.expectedExceptionClass() != null) {
+                if (!ec.expectedExceptionClass().isAssignableFrom(e.getClass())) {
+                    fail("Exception of wrong type " + e.getClass() + " is produced!");
+                }
+            }
+            if (ec.expectedExceptionMessage() != null) {
+                assertEquals("Wrong exception message", ec.expectedExceptionMessage(),
+                             e.getMessage());
+            }
+        }
+    }
+
+    protected void traverseComponentTree(final Component root, final TraverseAction action)
{
+        action.componentTraversed(root);
+        if (root instanceof Container) {
+            for (int i = 0; i < ((Container)root).getComponentCount(); i++) {
+                traverseComponentTree(((Container)root).getComponent(i), action);
+            }
+        }
+    }
+
+    protected void rethrow(final Throwable exception) throws Throwable {
+        String msg = exception.getMessage();
+        if (!ignoreNotImplemented || msg == null
+                || exception.getMessage().indexOf("implemented") == -1) {
+            throw exception;
+        }
+    }
+
+    protected void waitForIdle() throws Exception {
+        if (SwingUtilities.isEventDispatchThread()) {
+            getRobot().waitForIdle();
+        } else {
+            SwingUtilities.invokeAndWait(new Thread());
+        }
+    }
+
+    protected boolean hasListener(final EventListener[] listeners, final Class<?> listenerClass)
{
+        return getListener(listeners, listenerClass) != null;
+    }
+
+    protected EventListener getListener(final EventListener[] listeners, final Class<?>
listenerClass) {
+        for (EventListener element : listeners) {
+            if (element.getClass().isAssignableFrom(listenerClass)) {
+                return element;
+            }
+        }
+
+        return null;
+    }
+
+    protected boolean waitForFocus(final Component c) throws Exception {
+        int counter = 0;
+        while(true) {
+            if (isFocusOwner(c)) {
+                return true;
+            }
+            Thread.sleep(100);
+            counter++;
+            if (counter > 10) {
+                return false;
+            }
+        }
+    }
+
+    protected boolean isSystemWindow(final Frame f) {
+        return "JUnit".equals(f.getTitle());
+    }
+
+    protected Component findComponent(final Container root, final Class<?> findClass,
final boolean exactClassMatch) {
+        if (exactClassMatch && findClass == root.getClass()
+            || !exactClassMatch && findClass.isAssignableFrom(root.getClass())) {
+
+            return root;
+        }
+
+        for (int i = 0; i < root.getComponentCount(); i++) {
+            Component child = root.getComponent(i);
+            if (child instanceof Container) {
+                child = findComponent((Container)child, findClass, exactClassMatch);
+                if (child != null) {
+                    return child;
+                }
+            } else if (exactClassMatch && findClass == child.getClass()
+                       || !exactClassMatch && findClass.isAssignableFrom(child.getClass()))
{
+
+                return child;
+            }
+        }
+
+        return null;
+    }
+
+    private boolean isFocusOwner(final Component c) throws Exception {
+        final Marker result = new Marker();
+        SwingUtilities.invokeAndWait(new Runnable() {
+            public void run() {
+                result.setOccurred(c.isFocusOwner());
+            }
+        });
+
+        return result.isOccurred();
+    }
+
+    private Robot getRobot() throws Exception {
+        if (robot == null) {
+            robot = new Robot();
+        }
+
+        return robot;
+    }
+
+    private void closeAllFrames() {
+        Frame[] frames = Frame.getFrames();
+        for (Frame f : frames) {
+            if (f.isDisplayable()) {
+                if (!isSystemWindow(f)) {
+                    f.dispose();
+                }
+            }
+        }
+    }
+}

Propchange: harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/BasicSwingTestCase.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/SwingTestCase.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/SwingTestCase.java?view=auto&rev=479469
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/SwingTestCase.java
(added)
+++ harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/SwingTestCase.java
Sun Nov 26 16:07:04 2006
@@ -0,0 +1,54 @@
+/*
+ *  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.
+ */
+
+/**
+ * @author Alexey A. Ivanov, Anton Avtamonov
+ * @version $Revision$
+ */
+package javax.swing;
+
+import java.awt.EventQueue;
+
+/**
+ * A wrapper for Swing package unit tests. It wraps the real test code so that
+ * it is executed in the event dispatch thread.
+ *
+ */
+public abstract class SwingTestCase extends BasicSwingTestCase {
+    public SwingTestCase() {
+    }
+
+    public SwingTestCase(final String name) {
+        super(name);
+    }
+
+    @Override
+    protected Throwable runBareImpl() throws Throwable {
+        final Throwable[] exception = new Throwable[1];
+        EventQueue.invokeAndWait(new Runnable() {
+            public void run() {
+                try {
+                    runBareSuper();
+                } catch (Throwable e) {
+                    exception[0] = e;
+                }
+            }
+        });
+        
+        return exception[0]; 
+    }
+}

Propchange: harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java/common/javax/swing/SwingTestCase.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message