That’s what I know from Nunit. For me it’s more natural behaviour. I definitely will check dpUnit.

I’m not sure I understand exactly what you ask, but this is what would happen with your example test case:

1. an instance of TestClass is created
2. setUp runs
3. test1 runs
4. tearDown runs
5. another instance of TestClass is created
6. setUp runs
7. test2 runs
8. tearDown runs
9. a third instance of TestClass is created
10. setUp runs
11. test3 runs 12 tearDown runs

Each test is run in its own instance of the test case class.

If this bothers you very much switch to dpUnit which does this instead:

1. an instance of TestClass is created
2. setUp runs
3. test1 runs
4. tearDown runs
5. setUp runs
6. test2 runs
7. tearDown runs
8. setUp runs
9. test3 runs
10. tearDown runs

…which makes more sense. dpUnit also supports asynchronous setUp and some other things that FlexUnit don’t have. I’ve switched myself and I’m not looking back.

public function test2():void { }

public function test3():void { } } we’ll always run(means creates instances) this class 3 times for each test? And it doesn’t matter if i using function suite( )approach or dynamic look-up approach.

Is it true?

I’m asking it because i have class with very long and heavy start-up. And when i testing it i want to perform this init only once. There is no problem with this in NUnit for example. But i can’t figure out how to do it with flexunit.

Thanks in advance.

I just found this post, and didn’t realize that passing a calss through to the test suite would discover all the test classes.

I also am not a fan of the testSuite.add(xxx) method — I went through the pain of this approach for an entire project, and ditched.

As an alternative, I wrote a custom parser using metadata to allow me to decorate methods with [Test] to generate a test. I still prefer it over the name method approach. (Though probably would’ve have developed it had I known).

Details on my blog here: http://martypitt.wordpress.com/2008/03/16/custom-metatags-and-slicker-unit-tests/

Marty

It turns out that my defined set of input values ends up in 192000 tests once I’d written a function to get me all the possible combinations… Running an individual test for each combination allows me to see progress while the test runs and doesn’t lock up the flash player as each test is run on a different frame…

I’m not sure what the recommended way of testing a situation like this would be (a complex function which can have 192000 legal combinations of arguments passed in)?

(Let y be a dictionary mapping parameter value to expected result)

for ( var x in y ) { var expected = y[x]; var result = methodToTest(x);

assertEquals(”Test with parameter value ‘” + x + “‘ failed”, expected, result); }

If that fails the message will read something like “Test XXX failed: Test with parameter value ‘X’ failed, expected <A> but was <B>”.

Tests should be self-contained, you shouldn’t use the code that starts the tests to determine which values are tested.

Basically I have once complex method that I need to test with a large variety of input values. Rather than creating a different test for each possible input value (a large but defined set) I instead loop over all of the possible input values and create a TestCase for each - passing the values into the constructor. The TestCase subclass only contains one test method which uses all of the values passed into the constructor.

This allows me to have all of the tests run as individual tests so that I can see which one (if any fails).

I’m interested to know if you think this is a valid use-case (if I explained it clearly enough).

Cheers :)