At first, the question looks superfluous. For a decently sized product, no one would even think of writing all tests in a single file of course.
When it comes to functional/performance/integration/etc tests, these are usually involved to set up and already quite large by their nature, such that separation is again the obvious choice.
There is, however, the case of unit tests where we do have advantages when keeping tests in a single file:
- If the test file grows too large, it is an indication that your tested unit/class is too large as well. So what is a downside for other tests becomes a useful warning signal for unit tests.
- You have exactly all relevant tests for the respective unit together. Other tests, like integration tests, tend to encompass multiple system components, which means it is inherently difficult to identify all parts. For unit tests, there is always just that one unit, and it wouldn't make much sense to have to find multiple test files for it.
- Continuous testing: While you can theoretically run your whole test suite each time you save your source file, this is infeasible due to the long runtime of some more involved tests. Unit tests on the other hand are supposed to execute blazingly fast and having all tests for your unit in one file, you can edit away mercilessly whilst having the guarantee that on every save the complete unit is tested. This is possible in theory with split files as well, but practically, the CT tools assume one unit - one test.
The last reason above is sufficient for me personally to warrant not splitting unit tests. Especially with IDEs you get support for things like moving between unit and test code via a simple shortcut key, or in other words: there is absolutely no effort needed to find/execute/do anything with the relevant test code of your unit. Something which is simply no longer possible on tests that encompass multiple units.
So in summary, I'd argue that your given advantages are really only present for non-unit tests. When considering unit tests, quite the opposite holds true: having them in one file means they are easy to maintain and run, and as explained above, excessive size is useful as a code smell detector in that case.