import std.stdio;

//version=ASSIGNMENT_OPERATOR1;
version=ASSIGNMENT_OPERATOR2;

extern(C) void memcpy(void* dst, const void* src, size_t cnt);

// keep track of all living objects
bool[int*] s_living;

// canonical reference count dummy implementation
struct Count {
    int* count;
    int magic = 0x2f7d9a65;

    this(bool){
        count = new int;
        *count = 1;
        assert(count !in s_living);
        s_living[count] = true;
    }
    this(this){
        assert(magic == 0x2f7d9a65);
        if( count ){
            assert(*count > 0);
            (*count)++;
        }
    }
    ~this(){
        assert(magic == 0x2f7d9a65);
        if( count ){
            assert(*count > 0);
            if( --(*count) == 0){
                assert(count in s_living);
                s_living.remove(count);
                count = null;
            }
        }
        // reset just to catch uninitialized-errors better
        count = null;
        magic = 0;
    }

    version(ASSIGNMENT_OPERATOR1)
    {
        void opAssign(Count c)
        {
            assert(&this != &c); // note: c is passed by value
            assert(magic == 0x2f7d9a65);
            assert(c.magic == 0x2f7d9a65);
            typeid(Count).destroy(&this);
            memcpy(&this, &c, Count.sizeof);
            typeid(Count).postblit(&this);
        }
    }
    version(ASSIGNMENT_OPERATOR2)
    {
        void opAssign(Count c)
        {
            auto tmp = count;
            count = c.count;
            c.count = tmp;
        }
    }
}

void test_con_ass()
{
    Count c;
    { c = Count(true); }
    assert(c.count && *c.count == 1);
    { c = Count(); }
    assert(c.count == null);
}

void test_con_sae_ass()
{
    Count c[1];
    { c[0] = Count(true); }
    assert(*c[0].count == 1);
    { c[0] = Count(); }
    assert(c[0].count == null);
}

void test_con_ae_ass1()
{
    Count c[] = new Count[1];
    { c[0] = Count(true); }
    assert(c[0].count && *c[0].count == 1);
    { c[0] = Count(); }
    assert(c[0].count == null);
}

void test_con_ae_ass2()
{
    Count c[];
    { c ~= Count(true); }
    assert(c[0].count && *c[0].count == 1);
    { c[0] = Count(); }
    assert(c[0].count == null);
    { c ~= Count(true); }
    assert(c[0].count && *c[0].count == 1);
    Count tmp = c[0];
    assert(c[0].count && *c[0].count == 2);
    //{ c.length = 0; }
    { c[0] = Count(); c.length = 0; }
    assert(c[0].count && *c[0].count == 1);
    tmp = Count();
    assert(c[0].count == null);
}

void test_con_aa_ass1() // DMD 6178?
{
    Count[int] c;
    { auto cs = Count(true); c[0] = cs; }
    assert(c[0].count && *c[0].count == 1);
    { Count cs; c[0] = cs; }
    assert(c[0].count == null);
}

void test_con_aa_ass2() // DMD 6178?
{
    Count[int] c;
    { c[0] = Count(true); }
    assert(c[0].count && *c[0].count == 1);
    { c[0] = Count(); }
    assert(c[0].count == null);
}

void test_con_sm_ass()
{
    struct S { Count c; }
    S s;
    { s.c = Count(true); }
    assert(s.c.count && *s.c.count == 1);
    { s.c = Count(); }
    assert(s.c.count == null);
}

void test_con_cm_ass()
{
    class S { Count c; }
    S s = new S;
    { s.c = Count(true); }
    assert(s.c.count && *s.c.count == 1);
    { s.c = Count(); }
    assert(s.c.count == null);
}

void test_con_delp()
{
    Count c;
    void f(Count c_){ c = c_; }
    { f(Count(true)); }
    assert(c.count && *c.count == 1);
    { f(Count()); }
    assert(c.count == null);
}

void test_con_refp()
{
    Count c;
    static void f(ref Count cd, Count cs){ cd = cs; }
    { f(c, Count(true)); }
    assert(c.count && *c.count == 1);
    { f(c, Count()); }
    assert(c.count == null);
}

void test_con_refp2()
{
    Count c;
    static void f(ref Count cd, ref Count cs){ cd = cs; }
    { auto cs = Count(true); f(c, cs); }
    assert(c.count && *c.count == 1);
    { Count cs; f(c, cs); }
    assert(c.count == null);
}

void test_con_ptrp()
{
    Count c;
    static void f(Count* cd, Count cs){ *cd = cs; }
    { f(&c, Count(true)); }
    assert(c.count && *c.count == 1);
    { f(&c, Count()); }
    assert(c.count == null);
}

void test_con_ptrp2()
{
    Count c;
    static void f(Count* cd, Count* cs){ *cd = *cs; }
    { auto cs = Count(true); f(&c, &cs); }
    assert(c.count && *c.count == 1);
    { Count cs; f(&c, &cs); }
    assert(c.count == null);
}

void test_con_outp()
{
    Count c;
    static void f(out Count cd, Count cs){ cd = cs; }
    { f(c, Count(true)); }
    assert(c.count && *c.count == 1);
    { f(c, Count()); }
    assert(c.count == null);
}

void test_con_ret()
{
    Count c;
    static Count a(){ return Count(true); }
    static Count b(){ return Count(); }
    { c = a(); }
    assert(c.count && *c.count == 1);
    { c = b(); }
    assert(c.count == null);
}

void test_var_ret()
{
    Count c;
    static Count a(bool x = true){
        static Count cs;
        if( x && cs.count == null ) cs = Count(true);
        else if( !x && cs.count != null ) cs = Count();
        return cs;
    }
    static Count b(){ return a(); }
    { c = a(); }
    assert(c.count && *c.count == 2);
    { c = Count(); }
    assert(c.count && *c.count == 1);
    { c = b(); }
    assert(c.count && *c.count == 2);
    { c = Count(); }
    assert(c.count && *c.count == 1);
    a(false); // frees the static reference
}

void test_sae_ret() // DMD
{
    Count c;
    static Count a(bool x = true){
        static Count[1] cs;
        if( x && cs[0].count == null ) cs[0] = Count(true);
        else if( !x && cs[0].count != null ) cs[0] = Count();
        return cs[0];
    }
    { c = a(); }
    assert(c.count && *c.count == 2);
    { c = Count(); }
    assert(c.count && *c.count == 1);
    a(false); // frees the static reference
}

void test_ae_ret() // DMD 7530
{
    Count c;
    static Count a(bool x = true){
        static Count[] cs;
        if( x && cs.length == 0 ) cs ~= Count(true);
        else if( !x && cs.length > 0 ){ cs[0] = Count(); cs.length = 0; }
        return cs[0];
    }
    { c = a(); }
    assert(c.count && *c.count == 2);
    { c = Count(); }
    assert(c.count && *c.count == 1);
    a(false); // frees the static reference
}

void test_aae_ret()
{
    Count c;
    static Count a(bool x = true){
        static Count[int] cs;
        if( x && 0 !in cs ) cs[0] = Count(true);
        else if( !x && 0 in cs ) cs.remove(0);
        return cs[0];
    }
    { c = a(); }
    assert(c.count && *c.count == 2);
    { c = Count(); }
    assert(c.count && *c.count == 1);
    a(false); // frees the static reference
}

void test_sm_ret()
{
    Count c;
    struct S { Count c; }
    static Count a(bool x = true){
        static S cs;
        if( x && cs.c.count == null ) cs.c = Count(true);
        else if( !x && cs.c.count != null ) cs.c = Count();
        return cs.c;
    }
    { c = a(); }
    assert(c.count && *c.count == 2);
    { c = Count(); }
    assert(c.count && *c.count == 1);
    a(false); // frees the static reference
}

void test_tern_ret() // DMD 7516
{
    Count c;
    static Count a(bool x, bool y = true){
        static Count cs;
        if( y && cs.count == null ) cs = Count(true);
        else if( !y && cs.count != null ) cs = Count();
        return x ? cs : Count(0);
    }
    static Count b(bool x){ return x ? a(x) : Count(); }
    { c = a(true); }
    assert(c.count && *c.count == 2);
    { c = a(false); }
    assert(c.count && *c.count == 1);
    { c = b(true); }
    assert(c.count && *c.count == 2);
    { c = b(false); }
    assert(c.count && *c.count == 1);
    a(false, false); // frees the static reference
}

void test_str_ass()
{
    struct S { Count c; }
    S s, t;
    { s.c = Count(true); }
    assert(s.c.count && *s.c.count == 1);
    { t = s; }
    assert(s.c.count && *s.c.count == 2);
    assert(t.c.count && *t.c.count == 2);
    { t.c = Count(); }
    assert(s.c.count && *s.c.count == 1);
    { s = t; }
    assert(s.c.count == null);
    assert(t.c.count == null);
}

void test_str_sa_ass()
{
    struct S { Count[2] c; }
    S s, t;
    { s.c[0] = Count(true); }
    assert(s.c[0].count && *s.c[0].count == 1);
    { t = s; }
    assert(s.c[0].count && *s.c[0].count == 2);
    assert(t.c[0].count && *t.c[0].count == 2);
    { t.c[0] = Count(); }
    assert(s.c[0].count && *s.c[0].count == 1);
    { s = t; }
    assert(s.c[0].count == null);
    assert(t.c[0].count == null);
}

@property void test(alias F)()
{
    import std.stdio;
    writef("Test %s: ", F.stringof);
    version(BAILOUT){
        F();
        assert(s_living.length == 0);
    } else {
        try {
            F();
            if( s_living.length > 0 ){
                writeln("FAIL (leak)");
            } else writeln("OK");
            s_living = null;
        } catch(Throwable th){
            writeln("FAIL");
        }
    }
}

int main()
{
    test!test_con_ass;
    test!test_con_sae_ass;
    test!test_con_ae_ass1;
    test!test_con_ae_ass2;
    test!test_con_aa_ass1;
    test!test_con_aa_ass2;
    test!test_con_sm_ass;
    test!test_con_cm_ass;
    test!test_con_delp;
    test!test_con_refp;
    test!test_con_refp2;
    test!test_con_ptrp;
    test!test_con_ptrp2;
    test!test_con_outp;
    test!test_con_ret;
    test!test_var_ret;
    test!test_sae_ret;
    test!test_aae_ret;
    test!test_sm_ret;
    test!test_tern_ret;
    test!test_str_ass;
    test!test_str_sa_ass;
    return 1;
}