I often encouter the following pattern: A bug is resolved/closed as duplicate of another still open/unfixed bug.
I have trouble understanding the reasoning behind this strategy. From my naive point of view, there is at least one major downside: there is no easy way to verify that this is really a duplicate.
Normally, there is a pretty good heuristic to check whether a bug is fixed: Just run the reproducer/broken test and see if the result is right - almost everyone can do it. However, in the case of the duplicate-closure (as long as the original bug isn't fixed), verification can be done only by understanding the code and reasoning about it - and pretty often the only person being able do it, is the person closing the bug as duplicate.
A more sensible approach could be to mark the bug as duplicate, to resolve/close the duplicate-target, and only then to resolve/close the duplicate. Now the tester can easily verify that all problems are solved by running the reproducers.
Is closing a bug as duplicate of an unfixed bug considered a standard way of handling duplicate bugs? And if yes, why is it considered to be legit?