How to use Objects class of org.testng.collections package

The link you posted specifies that you can pass JVM arguments with a <jvmarg value="blah"/> element. Have you tried this?

<testng>
    <jvmarg value="-server"/>
    <jvmarg value="-Xmx128m"/>
    ...

1. Make your code stable so it doesn't randomly throw exceptions
2. Make your code stable so it handles intermittent problems correctly
3. If you're running unit tests, make them reasonable unit tests - execution time should be minimal.
4. If you're running integration tests, make sure you're only actually testing the boundaries between classes.

I think that's the best you're going to get with such a wide-open question.

I think it's quite important feature for JUnit, if author of JUnit doesn't want the order feature, why?

I'm not sure there is a clean way to do this with JUnit, to my knowledge JUnit assumes that all tests can be performed in an arbitrary order. From the FAQ:

How do I use a test fixture?

(...) The ordering of test-method invocations is not guaranteed, so testOneItemCollection() might be executed before testEmptyCollection(). (...)

Why is it so? Well, I believe that making tests order dependent is a practice that the authors don't want to promote. Tests should be independent, they shouldn't be coupled and violating this will make things harder to maintain, will break the ability to run tests individually (obviously), etc.

That being said, if you really want to go in this direction, consider using TestNG since it supports running tests methods in any arbitrary order natively (and things like specifying that methods depends on groups of methods). Cedric Beust explains how to do this in order of execution of tests in testng.

You got it exactly right: if you specify a testng.xml, it takes precedence over the command line switches.

Just add the following to your XML file:

  <groups>
    <run>
      <include name="foo"  />
    </run>
  </groups>

You can create a listener implementing IMethodInterceptor interface. Which will give you an ability to access groups list from your @Test and manage your "tests to execute list" as you need. At same time ITestContext parameter allows you to access the data from testNg xml. So, you can set groups to run in default testNg manner (suite xml file); but run them depending on algorithm you implement. Something like:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.testng.IMethodInstance;
import org.testng.IMethodInterceptor;
import org.testng.ITestContext;
import org.testng.annotations.Test;

public class Interceptor implements IMethodInterceptor
{

    @Override
    public List<IMethodInstance> intercept(List<IMethodInstance> methods, ITestContext context)
    {
        int methCount = methods.size();
        List<IMethodInstance> result = new ArrayList<IMethodInstance>();

        for (int i = 0; i < methCount; i++)
        {
            IMethodInstance instns = methods.get(i);
            List<String> grps = Arrays.asList(instns.getMethod().getConstructorOrMethod().getMethod().getAnnotation(Test.class).groups());
//get these groups from testng.xml via context method parameter                         
            if (grps.contains("A") && grps.contains("B"))
            {
                result.add(instns);
            }                       
        }                       
        return result;
    }
}

Without knowing precisely which logging library you are using, I would guess that the answer is almost certainly not unless you want to explicitly specify a newline character everywhere else.

The java.util.logging (and Log4J) frameworks allow you to plugin formatters to format your statements. You'd need to specify a format which did not end with a newline character. For example, in Log4J. they give an example pattern as

 %-5p [%t]: %m%n

So if you removed everything except the %m (the %n is the newline and the other stuff includes the time and log-level; %t and %p respectively, I think), newlines would not be automatically appended to each statement.

However, this means that everywhere else, your other log statements would have to look like this:

log.info("I want this on one line\n");

So...

Your prerequisites:

• excel file, each row - one dataset
• run test for each dataset

What can you do:

1. Create @DataProvider which return Iterator<Object[]> with your datasets where each Object[] is your row from excel. (the easiest one)
2. Use @Factory to manually iterate through your datasets and call test methods.
3. Use @DataProvider to provide data for @Factory and do as above. The 2nd and 3rd options are complicated, but have some benefits if you has other parameters, except datasets, to run tests.

You could also check imports for imported Test annotation, should be:

import org.testng.annotations.Test;
@Test
public myTest(){ ... }

and not for example:

import org.junit.Test;

I got this to work by reversing the lte and gte calls. I wrote a test to show it working:

@Test
public void shouldBeAbleToQueryBetweenTwoDates() throws Exception {
    // setup
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss'Z'");

    MongoTemplate mongoTemplate = new MongoTemplate(new Mongo(), "TheDatabase");
    DBCollection collection = mongoTemplate.getCollection("myObject");
    // cleanup
    collection.drop();

    // date that should match
    Date expectedDate = dateFormat.parse("2013-06-12T00:00:00Z");
    collection.insert(new BasicDBObject("cd", expectedDate));
    // date that should not match (it's last year)
    collection.insert(new BasicDBObject("cd", dateFormat.parse("2012-06-12T00:00:00Z")));

    // create and execute the query
    final Date to = dateFormat.parse("2013-06-30T09:12:29Z");
    final Date from = dateFormat.parse("2013-06-11T09:12:29Z");

    Query query = new Query();
    query.addCriteria(Criteria.where("cd").gte(from).lte(to));

    // check it returned what we expected
    List<MyObject> basicDBObjects = mongoTemplate.find(query, MyObject.class);
    Assert.assertEquals(1, basicDBObjects.size());
    Assert.assertEquals(expectedDate, basicDBObjects.get(0).cd);
}

Notes:

• This is TestNG not JUnit
• I'm using SimpleDateFormat just to make testing of dates easier and (maybe) more readable

The main thing to note is:

query.addCriteria(Criteria.where("cd").gte(from).lte(to));

Before I reversed the order of the lte and gte the query was returning nothing.