Is java.util.Optional<T> map function thread-safe ? If yes, How can I test it?

Optional.map is as thread-safe as the function you pass in as the parameter. Essentially all it does is:

public <V> Optional<V> map(Function<? super T, ? extends V> fn) {
  if (isPresent()) {
    V value = fn.apply(get());
    if (value != null) {
      return Optional.of(value);
    }
  }
  return Optional.absent();
}

Since Optional is immutable (meaning that isPresent() and get() always return the same value, and the value returned by get() will have been safely published), the only thing here that could possibly be thread-unsafe is the call fn.apply(get()).

As long as the mapping function in the argument is thread-safe, can we assume the overall operation will be thread safe ? How can I test this ?

With great difficulty. You can't really write a test to prove that something is thread-safe, because you can't prove the reason you didn't observe thread-unsafety is because of the correctness of your code, or because your test simply didn't do anything that would exercise the thread-unsafety.

You can only do this by reasoning about the code with respect to the properties of the Java Memory Model.

In a couple of situations I have been able to demonstrate the thread-unsafety of a class or method by spawning two or more threads calling the method repeatedly until one either gets a wrong result or an exception. As Andy Turner already said, even if the method is thread-unsafe, there is no guarantee that your test will reveal it. In some situations it will in practice.

Since Optional is immutable, it is thread-safe. So in this case your test will not show anything (unless the function you pass to map() is thread-unsafe). So you will have to decide yourself whether that leaves you more assured than you already were.