Contracts with interface

[tchaloupka via Digitalmars-d-learn]

This bites me again:

import std.stdio;
interface ITest
{
    void test();

    void test2()
    in { writeln("itest2"); }

    void test3()
    in { writeln("itest3"); }

    void test4()
    in { writeln("itest4"); assert(false); }
}

class Test: ITest
{
    void test()
    in { writeln("ctest"); }
    body { }

    void test2()
    {
    }

    void test3()
    in { writeln("ctest3"); }
    body {}

    void test4()
    in { writeln("ctest4"); }
    body {}
}

void main()
{
    auto t = new Test();
    t.test();
    t.test2();
    t.test3();
    t.test4();
}

What is expected output?

Docs says just:
Interface member functions can have contracts even though there 
is no body for the function. The contracts are inherited by any 
class member function that implements that interface member 
function.

and:
If a function in a derived class overrides a function in its 
super class, then only one of the in contracts of the function 
and its base functions must be satisfied. Overriding functions 
then becomes a process of loosening the in contracts.
A function without an in contract means that any values of the 
function parameters are allowed. This implies that if any 
function in an inheritance hierarchy has no in contract, then 
in contracts on functions overriding it have no useful effect.

What I expected is, that if there is no contract in interface and 
is in class implementation - it will be called. Or if interface 
has contract and class implementation doesn't, it will be called 
too.

But apparently it works the way that you have to have the same IN 
contract in both interface and class implementation to be safe. 
So it works the same way as with class inheritance per docs.
Which seems at least to me a bit strange and not much usable. 
What's the point of defining contract in interface just to write 
it again in the implementation class?
It's simpler to just write it in the class method body and not 
use the IN contracts at all.
At least a warning would be nice.