My feeling is that this would only be worthwhile if you had lots of on-the-edge hand-coded assembly language or some kind of incredibly tight timings (which you re not going to meet with that selection of OS anyway).

If you re using off-the-shelf commercial compilers, then you can be reasonably sure they re going to generate code which runs on all the normal processors.

Of course, nobody could ever prove they didn t need to test on a particular platform, but I would think there are bigger causes of platform difference to worry about than CPU brand (all the various multi-core/hyperthreading permutations, for example, which might expose all your multithreaded code bugs in different ways)

Only if you re programming in assembly and use extended, vender specific instruction sets. But since AMD and Intel have cross-licensing agreements in place, this is more of an historic issue than a current one.

In every other case (e.g. using a high level language) it s the job of the compiler writers to ensure the code is x86 compliant and runs on every CPU.

Oh, and except the FDIV Bug Processor vendors usually don t do mistakes.

I think you re looking in the wrong direction for testing scenarios.

Yes, it s possible that your code will work on Intel but not on AMD, or in Windows Vista Home but not in Windows Vista Professional. But unless you re doing something very closely tied to low-level programming in the first case, or to details of OS implementation in the second, the odds are small. You could say that it never hurts to test every conceivable scenario. But in real life there must be some limit on the resources available to you for testing. Testing on different processors or different OS s is, in most cases, not testing YOUR program, it s testing the compiler, the OS, or the processor. How much time do you have to spare to test other people s work? I think your time would be better spent testing more scenarios within your own code. You don t give much detail on just what your app does, but just to take one of my own examples, it would be much more productive to spend a day testing selling products our own company makes versus products we resell from other manufacturers, or testing sales tax rules for different states, or whatever.

In practice, I rarely even test deploying on Windows versus deploying on Linux, never mind different versions of Windows, and I rarely get burned on that.

If I was writing low-level device drivers or some such, that would be a different story. But normal apps? Don t waste your time.

Certainly sounds like it would be a waste of time to me - which language(s) are your programs written in?

I d say no. Unless you are writing your application in assembler, you should be far enough removed from the processor to not need to worry about differences. The processors will support the Windows OS whose API s are what you are interefacing with(depending on the language). If you are using .NET the ONLY forseeable issue you will have is if you are using a version of the framework that those platforms don t support. Given that they are all XP or later you should be fine. If you want to worry about something make sure your application will play nicely with the Vista and later security model.

The question is probably "what are you testing". It is unlikely that any of the test is testing something that would be potentially different between AMD and Intel hardware platforms. Differences could be expected at driver level, but you do not seems to plane testing your software for every existing bit of PC hardware available around. Most probably there would be much more differences between different levels of windows service pack than between AMD and Intel processors.

I suppose it s possible there is some functionality in your code that (whether you know it or not) takes advantage of some processing/optimization in one or the other that could have a serious effect on the outcome. Keyword possible.

I would say in general you re unlikely to have to worry about it. If you re going to do it on multiple machines anyway, mix it up on them. But I wouldn t stress out about it.

I would never run all of my regression tests on both AMD and Intel unless I had specifically fixed an issue unique to one either one. That is what regression testing is.

Unit testing on the other hand... I wouldn t anticipate any difference. So again, I wouldn t bother running unit tests on both until I had actually seen an issue specific to either AMD or Intel.

If you rely on accurate / consistent floating point results, then yes, definitely.