JUnit problem

altså noget ala tearDown...den skal bare kaldes til sidst i forhold til HELE testen

hmmm..skal da vist bare nedarve fra TestSuite og override dens tearDown metode :-)

det var vist ikke helt rigtigt...override TestSetup's tearDown, men jeg kan ikke få det til at virke ordentligt

ideen er den skal starte en server inden testen starter...og lukke serveren når testen er slut.

Normalt har man da ikke main i sin JUnit kode !?!?

Den leverer JUnit.

det var så jeg kunne køre det fra ide...men det har vist ikke noget med problemet at gøre

Jeg tror det er svært at gøre med JUnit. Hele ideen er at den enkelte
tests er self-contained og derfor kaldes setup og teardown før og
efter hver test.

Bedste workaround tror jeg vil være at køre JUnit testene via et anst task
som tager sig af start og stop.

ved ikke helt hvad du mener...

hvordan virker TestSetup egentlig...for jeg prøvede som sagt at lave min egen testsetup og gav min suite med som parameter...men det virkede ikke

Hm.

Det TestSetup ser lovende ud til det du vil.

Men jeg ar aldrig prøvet at bruge det (og jeg har brugt rigtigt
meget JUnit).

Som jeg læser dokumentationen så laver du en klasse der:
- extender TestSetup
- constructor kalde super-constructor med der der skal testes
- indeholder setUp og tearDown klasser der gør det du vil

og så kører du den "normalt".

arne_v: gider du prøve :-)...

Min testsetup ser sådan ud
package com.test;

import junit.extensions.*;
import junit.framework.*;

import com.ftp.server.*;

public class FtpTestSetup extends TestSetup
{
  public FtpTestSetup( Test test )
  {
    super( test );
  }
 
  public void setUp()
  {
    Server.getServer().start();
  }
 
  public void tearDown()
  {
    System.out.println( "Så er det slut" );
    Server.getServer().shutdown();
  }
}

og i samlettest.java har jeg så tilføjet

    new FtpTestSetup( suite );

Så er det slut bliver aldrig udskrevet :-(

import junit.framework.*;

public class AllTests extends TestCase {

  public AllTests(String s) {
    super(s);
  }

  public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTest(new SetupTestFun());
    return suite;
  }
}


import junit.extensions.*;
import junit.framework.*;

public class SetupTestFun extends TestSetup {

    public SetupTestFun() {
        super(new TestFun("testFun"));
    }

    public void setUp()
    {
        System.out.println( "Så starter vi" );
    }

    public void tearDown()
    {
        System.out.println( "Så er det slut" );
    }
}


import junit.framework.*;

public class TestFun extends TestCase {

    public TestFun(String s) {
        super(s);
    }

    protected void setUp() {
    }

    protected void tearDown() {
    }

    public void testFun() {
        System.out.println("OK");
    }
}

Men det er der jo ikke meget sjov ved (det er kun en metode man kalder).

Hvorfor ikke lade en normal TestCase setUp teste for om serveren er
startet (public static boolean alreadyStarted = false) og hvis ikke
starte den (og sætte flaget).

Nedlukning kan du så lave med et shutdown
hook (Runtime.getRuntime().addShutdownHook).

Simpelt men det bør virke.

jeg er ikke med på det med nedlukning

Et shutdown hook er at du beder JVM'en køre en tråd lige
inden den lukker ned.

Og mit forslag var at du bad dit test program lukke serveren
som det sidste.

Men hvor skal jeg placerer koden til det ?

og det skal ikke være ved afslutning af selve junit...kun af selve testen

Du kan kalde addShutdownHook med noget der lukker
serveren ned samme sted som du starter serveren.

Det bliver først udført når JVM'en lukkes ned.

Snakker jeg sort ?

Skal bare returnerer TestSetup istedet for suiten

Nu har du jo fået løst dit problem, men hvis andre skule være interesseret
i mit forslag.

AllTest.java
------------

package test;

import junit.framework.*;

public class AllTests extends TestCase {

    public AllTests(String s) {
        super(s);
    }

    public static Test suite() {
        TestSuite suite = new TestSuite();
        suite.addTestSuite(test.TestC1.class);
        suite.addTestSuite(test.TestC2.class);
        return suite;
    }
}

TestC1.java
-----------

package test;

import junit.framework.*;

public class TestC1 extends TestCase {

    public TestC1(String s) {
        super(s);
    }

    protected void setUp() {
        System.out.println("C1 setUp");
        Server.check();
    }

    protected void tearDown() {
        System.out.println("C1 tearDown");
    }

    public void testM1() {
        System.out.println("C1 M1");
    }

    public void testM2() {
        System.out.println("C1 M2");
    }
}

TestC2.java
-----------

package test;

import junit.framework.*;

public class TestC2 extends TestCase {

    public TestC2(String s) {
        super(s);
    }

    protected void setUp() {
        System.out.println("C2 setUp");
        Server.check();
    }

    protected void tearDown() {
        System.out.println("C2 tearDown");
    }

    public void testM1() {
        System.out.println("C2 M1");
    }

    public void testM2() {
        System.out.println("C2 M2");
    }
}

Server.java
-----------

package test;

public class Server {
    private static boolean started = false;
    public static void check() {
        if(!started) {
            System.out.println("startup server");
            Runtime.getRuntime().addShutdownHook(new StopServer());
            started = true;
        }
    }
}

class StopServer extends Thread {
    public void run() {
        System.out.println("shutdown server");
    }
}

output
------

C1 setUp

startup server

C1 M1

C1 tearDown

C1 setUp

C1 M2

C1 tearDown

C2 setUp

C2 M1

C2 tearDown

C2 setUp

C2 M2

C2 tearDown

shutdown server

mit forslag er blot en ændring i suite metoden

public class SamletTest
{
  public static Test suite()
  {
    TestSuite suite = new TestSuite();

    suite.addTestSuite( blabla );

    TestSetup testSetup = new TestSetup( suite )
    {
      //implementation af setUp og tearDown
    };

    return suite;
  }

ups...og return testSetup

Aha.

I mit eksempel ville det være:

package test;

import junit.framework.*;
import junit.extensions.*;

public class NewAllTests extends TestCase {

    public NewAllTests(String s) {
        super(s);
    }

    public static Test suite() {
        TestSuite suite = new TestSuite();
        suite.addTestSuite(test.TestC1.class);
        suite.addTestSuite(test.TestC2.class);
        TestSetup setup = new TestSetup( suite )
        {
            public void setUp() {
                System.out.println("startup server");
            }
            public void tearDown() {
                System.out.println("shutdown server");
            }
        };
        return setup;
    }
}

og det virker også.

Og det er noget mere kompakt kodemæssigt.

Men du kan ikke længere køre test casene standalone.