I used to hate the expression: (A==B)==(X==Y), but I've grown very fond of it. 

My prior feelings of contempt stem from my desire to avoid obscure language features. But I figure when properly parenthesized, this isn't so obscure and can be pretty useful and concise. Unlike operator precedence, you don't need to go lookup a table to parse it.


Where is this useful?

I find it's really useful for concisely checking that multiple values are in sync. For example, asserts like this:

Foo * p;
HRESULT hr = GetFoo(&p);

Assert(SUCCEEDED(hr) == (p != NULL));

In this case, either the function succeeded and gave you back a non-null object; or it failed and gave you a null-object. (This is of course assuming that's GetFoo's contract. Some functions leave their out-parameters undefined on failure).

Or this:

void SomeStringFunction(const BYTE * pBuffer,  DWORD cbLength) {
    Assert((pBuffer == NULL) == (cbLength == 0));

This asserts that either you have a pointer to a non-zero-length buffer or you don't have anything at all.