IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

AWT/Swing Java Discussion :

Est-il possible de tester une classe Swing avec l'API de test JUnit sous Eclipse ?


Sujet :

AWT/Swing Java

  1. #1
    Candidat au Club
    Profil pro
    Inscrit en
    Mars 2013
    Messages
    5
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2013
    Messages : 5
    Points : 2
    Points
    2
    Par défaut Est-il possible de tester une classe Swing avec l'API de test JUnit sous Eclipse ?
    Bonjour à tous,

    je ne parviens pas à trouver la réponse à ma question dans la FAQ.

    Savez vous si il est possible de tester une classe Swing dans Eclipse Kepler Service Release 2 avec JUnit-4.7 ?

    Je cherche à tester des GUI (Graphic User Interface) écrites avec Java jdk1.7.0_65 et notamment son API Swing.

    J'ai une classe qui m'ouvre une JFrame contenant un JPanel et ses composants. Lorsque je teste cette classe dans une classe applicative (avec méthode main(...)) en ouvrant un Thread EDT, tout fonctionne parfaitement.
    La fenêtre s'affiche et je vois tout ce qui doit apparaitre à l'écran.

    Je souhaiterais savoir si il est possible de faire la même chose dans une méthode d'un Test JUnit-4.7 sous Eclipse Kepler.
    J'utilise le JUnit dans Eclipse Kepler (JUnit-4.7.jar déclaré dans mes librairies) et j'essaie de faire un JUnit Test case comme pour les classes non graphiques.

    Le test JUnit semble se dérouler normalement (barre verte) avec une classe graphique Swing, mais je ne parviens pas à afficher la JFrame contenant un JPanel et ses composants.

    Je suppose que le Thread EDT gérant l'affichage des composants graphiques Swing peut poser problème mais je suis trop court en Java pour pouvoir me dépêtrer de ce souci.

    Quelqu'un aurait-il trouvé une solution dans Eclipse Kepler ? Merci d'avance.

    Cordialement,

    Daniel Lévy
    dany.levy@free.fr

  2. #2
    Invité
    Invité(e)
    Par défaut
    Vous pouvez éventuellement créer un script de test utilisant la classe Robot

  3. #3
    Candidat au Club
    Profil pro
    Inscrit en
    Mars 2013
    Messages
    5
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2013
    Messages : 5
    Points : 2
    Points
    2
    Par défaut Merci beaucoup
    Citation Envoyé par chanyslas Voir le message
    Vous pouvez éventuellement créer un script de test utilisant la classe Robot
    Merci beaucoup. Je vais donc essayer cette classe Robot.

  4. #4
    Expert éminent sénior
    Avatar de tchize_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2007
    Messages
    25 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Avril 2007
    Messages : 25 481
    Points : 48 806
    Points
    48 806
    Par défaut
    La classe robot, selon moi, c'est overkill pour du unit test. Ca va simuler des clic et des entrées souris via le système natif de l'OS. Autrement dit, si ça clic à coté, tu peux balancer tout ton test au final dans un email, effacer des fichiers dans l'exploreur, etc. Assez dangereux et de toutes façons très difficile d'avoir un feedback pour le tapper dans un Assert.

    Personellement, quand je dois tester que des composants swings se comportent correctement, c'est souvent des tests de synchro. Genre "a tiens, si je sélectionne tel élement dans la liste, tel et tel JTextField doivent s'activer". Et ça c'est assez facile à tester. Tu instancie la JFrame, tu crée un getter pour avoir la JList et les textfields, et ton test deviens


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    Fenetre maFenetre = new Fenetre();
    maFenetre.getLaListe().setSelectedIndex(3);
    assetEquals("Tartempion",maFenetre.getNameField().getText());
    Pour des chose un peu plus complexe, genre "HA si je clique droit sur le JLabel, une JPopup dois apparaitre", c'est plus complexe. Tu peux facilement balancer l'event via processMouseEvent() sur le composant. Pour détecter l'affichage de la JPopup, tu pourrais utiliser powerMockito pour intercepter les new sur JPopupMenu et en conclure que, oui, on a bien lancer une popup. Ou diviser mieux ton code pour que la popup soit gérée par une classe à part facilement mockable.

    Pour le reste, les interactions complexe, rien ne vaut l'oeil du testeur au final.

  5. #5
    Candidat au Club
    Profil pro
    Inscrit en
    Mars 2013
    Messages
    5
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2013
    Messages : 5
    Points : 2
    Points
    2
    Par défaut Incompatibilité entre le Thread EDT et JUnit ?
    Citation Envoyé par tchize_ Voir le message
    La classe robot, selon moi, c'est overkill pour du unit test. Ca va simuler des clic et des entrées souris via le système natif de l'OS. Autrement dit, si ça clic à coté, tu peux balancer tout ton test au final dans un email, effacer des fichiers dans l'exploreur, etc. Assez dangereux et de toutes façons très difficile d'avoir un feedback pour le tapper dans un Assert.

    Personellement, quand je dois tester que des composants swings se comportent correctement, c'est souvent des tests de synchro. Genre "a tiens, si je sélectionne tel élement dans la liste, tel et tel JTextField doivent s'activer". Et ça c'est assez facile à tester. Tu instancie la JFrame, tu crée un getter pour avoir la JList et les textfields, et ton test deviens


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    Fenetre maFenetre = new Fenetre();
    maFenetre.getLaListe().setSelectedIndex(3);
    assetEquals("Tartempion",maFenetre.getNameField().getText());
    Pour des chose un peu plus complexe, genre "HA si je clique droit sur le JLabel, une JPopup dois apparaitre", c'est plus complexe. Tu peux facilement balancer l'event via processMouseEvent() sur le composant. Pour détecter l'affichage de la JPopup, tu pourrais utiliser powerMockito pour intercepter les new sur JPopupMenu et en conclure que, oui, on a bien lancer une popup. Ou diviser mieux ton code pour que la popup soit gérée par une classe à part facilement mockable.

    Pour le reste, les interactions complexe, rien ne vaut l'oeil du testeur au final.
    Merci beaucoup,

    en fait, ma question portait plus sur le problème du Thread EDT pour l'affichage graphique. Quand je fais une classe applicative avec une méthode main comme suit :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    public static void main(final String[] args) {
     
    		/* Utilise le Event Dispatch Thread (EDT). */
    		SwingUtilities.invokeLater(new Runnable() {
     
    			@Override
    			public void run() {
     
    				/* Création d'une JFrame. */
    				final JFrame frame = new JFrame();
     
    				/* Création d'un JPanel. */
    				final JPanel panel = new JPanel();
     
    				/* Coloration et dimensionnement du panel. */
    				panel.setBackground(Color.BLUE);
    				panel.setPreferredSize(new Dimension(900, 700));
    				panel.setMinimumSize(new Dimension(900, 700));
     
    				/* Passe un GridBagLayout au ContentPane de la JFrame . */
    				frame.getContentPane().setLayout(new GridBagLayout());
     
    				/* Ferme l'application lorsque l'on ferme la fenêtre. */
    				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
    				/* Ajout du JPanel à la JFrame. */
    				frame.getContentPane().add(panel);
     
    				/* Met en place la JFrame. */
    		                frame.pack();
     
    		                /* Dimensionne la JFrame. */
    				frame.setSize(1000, 800);
     
    				/* JFrame redimensionnable. */
    				frame.setResizable(true);
     
    				/* JFrame centrée au mileu de l'écran. */
    				frame.setLocationRelativeTo(null);
     
    				/* Affichage de la JFrame. */
    				frame.setVisible(true);
     
    			} // Fin de Run().____________________________
     
    		}); // Fin de new Runnable()._______________________________
     
    	} // Fin de main(...)._________________________________________________
    Je lance dans Eclipse cette application. Tout fonctionne parfaitement et la JFrame s'affiche.

    Je ne parviens à faire la même chose au sein d'une méthode d'un test Junit. L'affichage semble impossible. Je suppose qu'il y a une incompatibilité entre l'utilisation du Thread EDT et l'API JUnit mais je n'en suis pas sûr.

    Je voulais donc savoir si il y avait une astuce permettant d'afficher du Swing dans un test JUnit (ouvrir un nouveau Thread, utilisation d'une classe SwingWorker, ....).

    Merci d'avance.

  6. #6
    Expert éminent sénior
    Avatar de tchize_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2007
    Messages
    25 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Avril 2007
    Messages : 25 481
    Points : 48 806
    Points
    48 806
    Par défaut
    La première chose que je ferais, c'est sortir du main le contenu de run(), ca te donne un point d'entrée pour ton unit test:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    public static JFrame startMainFrame(){
    				/* Création d'une JFrame. */
    				final JFrame frame = new JFrame();
     
    				/* Création d'un JPanel. */
    				final JPanel panel = new JPanel();
     
    				/* Coloration et dimensionnement du panel. */
    				panel.setBackground(Color.BLUE);
    				panel.setPreferredSize(new Dimension(900, 700));
    				panel.setMinimumSize(new Dimension(900, 700));
     
    				/* Passe un GridBagLayout au ContentPane de la JFrame . */
    				frame.getContentPane().setLayout(new GridBagLayout());
     
    				/* Ferme l'application lorsque l'on ferme la fenêtre. */
    				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
    				/* Ajout du JPanel à la JFrame. */
    				frame.getContentPane().add(panel);
     
    				/* Met en place la JFrame. */
    		                frame.pack();
     
    		                /* Dimensionne la JFrame. */
    				frame.setSize(1000, 800);
     
    				/* JFrame redimensionnable. */
    				frame.setResizable(true);
     
    				/* JFrame centrée au mileu de l'écran. */
    				frame.setLocationRelativeTo(null);
     
    				/* Affichage de la JFrame. */
    				frame.setVisible(true);
                                    return frame;
     
    }
     
    public static void main(final String[] args) {
     
    		/* Utilise le Event Dispatch Thread (EDT). */
    		SwingUtilities.invokeLater(new Runnable() {
     
    			@Override
    			public void run() {
     				startMainFrame();
     
    			} // Fin de Run().____________________________
     
    		}); // Fin de new Runnable()._______________________________
     
    	} // Fin de main(...)._________________________________________________
    Ensuite, tu peux commencer ton test comme ça:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
     
    JFrame aTester = null;
     
    @Test
    public void testFenetre() throws Exception { // Exception à clarifier
       SwingUtilities.invokeAndWait(new Runnable(){public void run(){aTester = Main.startMainFrame();}});
       // Laisse à swing le temps de consommer les évènement éventuellement créés par l'apparition de la fenêtre en se remettant à la fin.
       SwingUtilities.invokeAndWait(new Runnable(){public void run(){}}); 
       // Go pour le test
       assertNotNull(aTester);
       assertTrue(aTester.isVisible());
    }

  7. #7
    Candidat au Club
    Profil pro
    Inscrit en
    Mars 2013
    Messages
    5
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2013
    Messages : 5
    Points : 2
    Points
    2
    Par défaut
    Citation Envoyé par tchize_ Voir le message
    La première chose que je ferais, c'est sortir du main le contenu de run(), ca te donne un point d'entrée pour ton unit test:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    public static JFrame startMainFrame(){
    				/* Création d'une JFrame. */
    				final JFrame frame = new JFrame();
     
    				/* Création d'un JPanel. */
    				final JPanel panel = new JPanel();
     
    				/* Coloration et dimensionnement du panel. */
    				panel.setBackground(Color.BLUE);
    				panel.setPreferredSize(new Dimension(900, 700));
    				panel.setMinimumSize(new Dimension(900, 700));
     
    				/* Passe un GridBagLayout au ContentPane de la JFrame . */
    				frame.getContentPane().setLayout(new GridBagLayout());
     
    				/* Ferme l'application lorsque l'on ferme la fenêtre. */
    				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
    				/* Ajout du JPanel à la JFrame. */
    				frame.getContentPane().add(panel);
     
    				/* Met en place la JFrame. */
    		                frame.pack();
     
    		                /* Dimensionne la JFrame. */
    				frame.setSize(1000, 800);
     
    				/* JFrame redimensionnable. */
    				frame.setResizable(true);
     
    				/* JFrame centrée au mileu de l'écran. */
    				frame.setLocationRelativeTo(null);
     
    				/* Affichage de la JFrame. */
    				frame.setVisible(true);
                                    return frame;
     
    }
     
    public static void main(final String[] args) {
     
    		/* Utilise le Event Dispatch Thread (EDT). */
    		SwingUtilities.invokeLater(new Runnable() {
     
    			@Override
    			public void run() {
     				startMainFrame();
     
    			} // Fin de Run().____________________________
     
    		}); // Fin de new Runnable()._______________________________
     
    	} // Fin de main(...)._________________________________________________
    Ensuite, tu peux commencer ton test comme ça:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
     
    JFrame aTester = null;
     
    @Test
    public void testFenetre() throws Exception { // Exception à clarifier
       SwingUtilities.invokeAndWait(new Runnable(){public void run(){aTester = Main.startMainFrame();}});
       // Laisse à swing le temps de consommer les évènement éventuellement créés par l'apparition de la fenêtre en se remettant à la fin.
       SwingUtilities.invokeAndWait(new Runnable(){public void run(){}}); 
       // Go pour le test
       assertNotNull(aTester);
       assertTrue(aTester.isVisible());
    }
    Merci beaucoup Tchize_. Je vais tester ça et je te tiens au courant.

  8. #8
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par tchize_ Voir le message
    La classe robot, selon moi, c'est overkill pour du unit test. Ca va simuler des clic et des entrées souris via le système natif de l'OS. Autrement dit, si ça clic à coté, tu peux balancer tout ton test au final dans un email, effacer des fichiers dans l'exploreur, etc. Assez dangereux et de toutes façons très difficile d'avoir un feedback pour le tapper dans un Assert.
    Votre vision apocalyptique de l'utilisation de la classe Robot n'est pas très sérieuse et prête à sourire. Ce n'est pas parce que vous n'utilisez pas une fonctionnalité d'un langage qu'il faut la dénigrer avec autant de caricature.
    Je suis d'accord avec vous qu'elle manque encore de fonctionnalités et "viser" les composants n'est pas forcément très pratique, mais elle a le mérite d'exister et vient compléter les outils permettant de réaliser des tests.
    D'autre part, pour utiliser correctement cette classe, au lieu de "viser", vous pouvez utiliser les méthodes de focus sur les composants avant de faire intervenir le Robot ou faire en sorte que celui-ci utilise des commandes recevables par votre GUI (les accélérateurs, etc), plutôt que de le faire cliquer ou taper comme un gremlins. Il ne s'agit pas, dans cette discussion, de tests de robustesse.

  9. #9
    Expert éminent sénior
    Avatar de tchize_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2007
    Messages
    25 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Avril 2007
    Messages : 25 481
    Points : 48 806
    Points
    48 806
    Par défaut
    Citation Envoyé par chanyslas Voir le message
    Votre vision apocalyptique de l'utilisation de la classe Robot n'est pas très sérieuse et prête à sourire. Ce n'est pas parce que vous n'utilisez pas une fonctionnalité d'un langage qu'il faut la dénigrer avec autant de caricature.
    Ce n'est pas caricatural et part bien d'expériences personnelle. La classe Robot ne fait que créer des évenements systèmes et ceux si peuvent aussi bien arriver sur une de vos fenètre qu'à coté à cause d'un bug. Et quand le test et un test de drag and drop, ça se résume à un drag and drop "à coté". En l'occurence dans mon cas à l'époque c'est tombé dans le eclipse derrière qui a fait disparaitre un dossier du code pour le faire disparaitre dans un sous dossier obscur. C'est allé trop vite pour voir ce qui se passait et j'ai perdu une demi journée à remettre le projet en état...

    La plupart des tests n'ont pas besoin de Robot car on peut directement injecter les évènements sur la frame, qui dispatchera elle même aux différents composants. Du code swing c'est du code comme un autre, ce sont des objets avec des méthodes, et c'est testable de la même manière: on appelle les méthode, on met des mocks où il faut et on vérifie ce qui en sort.

    Bref, je parlais pas de faire travailler Robots comme un gremlings, mais d'éviter un triple travail de test à savoir:
    Tester que le code principal n'a pas de soucis (le but du unit test)
    Tester que le code de test ne pourra jamais dérapper (c'est la partie que je trouve overkill dans Robots selon moi)
    S'assurer pendant les 20 minutes que tourne le test qu'aucune andouille de collègue ne touchera votre clavier pour vous montrer un truc

  10. #10
    Candidat au Club
    Profil pro
    Inscrit en
    Mars 2013
    Messages
    5
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2013
    Messages : 5
    Points : 2
    Points
    2
    Par défaut A Mon avis, il y a conflit entre l'affichage d'un composant Swing et JUnit
    Citation Envoyé par tchize_ Voir le message
    Ce n'est pas caricatural et part bien d'expériences personnelle. La classe Robot ne fait que créer des évenements systèmes et ceux si peuvent aussi bien arriver sur une de vos fenètre qu'à coté à cause d'un bug. Et quand le test et un test de drag and drop, ça se résume à un drag and drop "à coté". En l'occurence dans mon cas à l'époque c'est tombé dans le eclipse derrière qui a fait disparaitre un dossier du code pour le faire disparaitre dans un sous dossier obscur. C'est allé trop vite pour voir ce qui se passait et j'ai perdu une demi journée à remettre le projet en état...

    La plupart des tests n'ont pas besoin de Robot car on peut directement injecter les évènements sur la frame, qui dispatchera elle même aux différents composants. Du code swing c'est du code comme un autre, ce sont des objets avec des méthodes, et c'est testable de la même manière: on appelle les méthode, on met des mocks où il faut et on vérifie ce qui en sort.

    Bref, je parlais pas de faire travailler Robots comme un gremlings, mais d'éviter un triple travail de test à savoir:
    Tester que le code principal n'a pas de soucis (le but du unit test)
    Tester que le code de test ne pourra jamais dérapper (c'est la partie que je trouve overkill dans Robots selon moi)
    S'assurer pendant les 20 minutes que tourne le test qu'aucune andouille de collègue ne touchera votre clavier pour vous montrer un truc
    Bonjour Tchize_

    J'ai réalisé ce que tu me préconisais.

    J'ai fait une première classe AfficheurFrame chargée d'instancier, décorer et afficher dans le Thread EDT la JFrame :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
     
    package levy.daniel.application.presentation.desktop.jframe;
     
    import java.awt.Color;
    import java.awt.Dimension;
    import java.awt.GridBagConstraints;
    import java.awt.GridBagLayout;
     
    import javax.swing.BorderFactory;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    import javax.swing.SwingConstants;
    import javax.swing.SwingUtilities;
    import javax.swing.border.BevelBorder;
     
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
     
     
    /**
     * class AfficheurFrame :<br/>
     * Classe applicative permettant d'instancier et d'afficher une JFrame.<br/>
     * - Possède une méthode main(...) permettant 
     * de la lancer comme une application Java.<br/>
     * - Affiche la JFrame dans l'Event Dispatch Thread (EDT).<br/>
     * <br/>
     */
    public final class AfficheurFrame {
     
    	// ************************ATTRIBUTS************************************/
     
    	/**
             * LOG : Log : Logger pour Log4j (utilisant commons-logging).
             */
    	@SuppressWarnings("unused")
    	private static final Log LOG = LogFactory.getLog(AfficheurFrame.class);
     
    	// *************************METHODES************************************/
     
     
    	 /**
             * method CONSTRUCTEUR AfficheurFrame() :<br/>
             * CONSTRUCTEUR D'ARITE NULLE.<br/>
             * Constructeur private pour bloquer l'instanciation externe.<br/>
             * <br/>
             */
    	private AfficheurFrame() {
    		super();
    	} // Fin de CONSTRUCTEUR D'ARITE NULLE.________________________________
     
     
     
    	/**
             * method creerEtAfficherFrame() :<br/>
             * Instancie, décore et affiche une JFrame.<br/>
             * <br/>
             * 
             * @return : JFrame : JFrame affichée.<br/>
             */
    	public static JFrame creerEtAfficherFrame() {
     
    		/* Instanciation d'une JFrame. */
    		final JFrame frame = new JFrame();
     
    		/* Création d'un JPanel pour décorer la JFrame. */
    		final JPanel panel = new JPanel();
    		panel.setLayout(new GridBagLayout());
     
    		/* Création d'un JLabel pour égayer le JPanel. */
    		final JLabel label = new JLabel("CA MARCHE");
    		label.setHorizontalAlignment(SwingConstants.CENTER);
    		label.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
    		label.setBackground(Color.WHITE);
    		label.setOpaque(true);
    		label.setPreferredSize(new Dimension(100, 40));
    		label.setMinimumSize(new Dimension(100, 40));
     
    		/* Ajout du JLabel au JPanel. */
    		panel.add(label, new GridBagConstraints());
     
    		/* Coloration et dimensionnement du panel. */
    		panel.setBackground(Color.BLUE);
    		panel.setPreferredSize(new Dimension(150, 100));
    		panel.setMinimumSize(new Dimension(150, 100));
     
    		/* Passe un GridBagLayout au ContentPane de la JFrame . */
    		frame.getContentPane().setLayout(new GridBagLayout());
     
    		/* Ajout du JPanel à la JFrame. */
    		frame.getContentPane().add(panel, new GridBagConstraints());
     
    		/* Ferme l'application lorsque l'on ferme la fenêtre. */
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
    		/* Met en place la JFrame. */
    		frame.pack();
     
    		/* Dimensionne la JFrame. */
    		frame.setSize(200, 150);
     
    		/* JFrame redimensionnable. */
    		frame.setResizable(true);
     
    		/* JFrame centrée au mileu de l'écran. */
    		frame.setLocationRelativeTo(null);
     
    		/* Affichage de la JFrame. */
    		frame.setVisible(true);
     
    		return frame;
     
    	} // Fin de creerFrame().______________________________________________
     
     
     
    	/**
             * method main() :<br/>
             * Point d'entrée de l'application.<br/>
             * Instancie, décore et affiche une JFrame.<br/>
             * - Ouvre un Thread EDT dédié à l'affichage.<br/>
             * <br/>
             *
             * @param args : String[].<br/>
             */
    	public static void main(final String[] args) {
     
    		/* Utilise le Event Dispatch Thread (EDT). */
    		SwingUtilities.invokeLater(new Runnable() {
     
    			/**
                             * {@inheritDoc}
                             */
    			@Override
    			public void run() {
     
    				/* Instancie, crée et affiche la JFrame dans le Thread EDT. */
    				creerEtAfficherFrame();
     
    			} // Fin de Run().____________________________
     
    		}); // Fin de new Runnable()._______________________________
     
    	} // Fin de main(...)._________________________________________________
     
     
     
    } // FIN DE LA CLASSE AfficheurFrame.----------------------------------------
    Lorsqu'on lance cette application (méthode main(..), on obtient l'affichage suivant :

    Nom : afficheurFrame.JPG
Affichages : 792
Taille : 13,6 Ko

    J'ai ensuite réalisé la classe de test JUnit AfficheurFrameTest comme tu me l'avais indiqué :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
     
    package levy.daniel.application.presentation.desktop.jframe;
     
    import static org.junit.Assert.*;
     
    import java.lang.reflect.InvocationTargetException;
     
    import javax.swing.JFrame;
    import javax.swing.SwingUtilities;
     
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.junit.Test;
     
     
    /**
     * class AfficheurFrameTest :<br/>
     * Test JUnit de la classe AfficheurFrame.<br/>
     * <br/>
     */
    public class AfficheurFrameTest {
     
    	// ************************ATTRIBUTS************************************/
     
     
    	/**
             * frameATester : JFrame :<br/>
             * JFrame à tester créée par un AfficheurFrame.<br/>
             */
    	private static JFrame frameATester;
     
     
    	/**
             * LOG : Log : 
             * Logger pour Log4j (utilisant commons-logging).
             */
    	@SuppressWarnings("unused")
    	private static final Log LOG = LogFactory.getLog(AfficheurFrameTest.class);
     
    	// *************************METHODES************************************/
     
     
    	/**
             * method testCreerEtAfficherFrame() :<br/>
             * TEST JUnit.<br/>
             * Teste l'affichage de la JFrame.<br/>
             * <br/>
             * @throws InterruptedException 
             * @throws InvocationTargetException 
             */
    	@Test
    	public void testCreerEtAfficherFrame() 
    			throws InvocationTargetException, InterruptedException {
     
    		/* L'invocation de invokeAndWait(...) au lieu de invokeLater(...) 
    		 * laisse à Swing le temps de consommer les évènement éventuellement 
    		 * créés par l'apparition de la fenêtre en se remettant à la fin.*/
    		SwingUtilities.invokeAndWait(new Runnable() {
     
    			/**
                             * {@inheritDoc}
                             */
    			@Override
    			public void run() {
     
    				/* CREATION DE LA JFrame. */
    				AfficheurFrameTest.setFrameATester(
    						AfficheurFrame.creerEtAfficherFrame());
     
    			} // Fin de Run().____________________________
     
    		}); // Fin de new Runnable()._______________________________
     
     
    		/* TESTS UNITAIRES. */
    		assertNotNull("La JFrame ne doit pas être null : ", frameATester);
    		assertTrue("La JFrame doit être visible : ", frameATester.isVisible());
     
    	} // Fin de testCreerEtAfficherFrame().________________________________
     
     
     
    	/**
             * method getFrameATester() :<br/>
             * Getter de la JFrame à tester créée par un AfficheurFrame.<br/>
             * <br/>
             *
             * @return frameATester : JFrame.<br/>
             */
    	public static final JFrame getFrameATester() {
    		return frameATester;
    	} // Fin de getFrameATester()._________________________________________
     
     
     
    	/**
             * method setFrameATester(
             * JFrame pFrameATester) :<br/>
             * Setter de la JFrame à tester créée par un AfficheurFrame.<br/>
             * <br/>
             *
             * @param pFrameATester : JFrame : 
             * valeur à passer à frameATester.<br/>
             */
    	public static final void setFrameATester(
    			final JFrame pFrameATester) {
    		frameATester = pFrameATester;
    	} // Fin de setFrameATester(
    	 // JFrame pFrameATester)._____________________________________________
     
     
     
    } // FIN DE LA CLASSE AfficheurFrameTest.------------------------------------
    Le test JUnit se déroule parfaitement (barre verte dans Eclipse). Mais la fenêtre apparaît de manière très fugace puis disparait. Elle ne reste pas affichée à l'écran.

    Il ne semble pas possible d'obtenir le même comportement de la JFrame dans un test JUnit que lorsque l'on utilise l'application AfficheurFrame.

    Je pense donc qu'il y a bien un conflit entre l'API JUnit et l'affichage d'un composant Swing.
    En revanche, ça ne gêne en rien pour tester avec JUnit.
    Fichiers attachés Fichiers attachés

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 4
    Dernier message: 26/01/2012, 18h46
  2. Réponses: 6
    Dernier message: 28/10/2011, 13h01
  3. Réponses: 2
    Dernier message: 28/09/2010, 20h00
  4. Réponses: 8
    Dernier message: 23/02/2008, 10h49
  5. est-il possible d'executer une requete SQL avec jvs?
    Par roxxxy dans le forum Général JavaScript
    Réponses: 4
    Dernier message: 19/04/2007, 16h53

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo