Hogyan kezeli Spock a megcsúfolt objektumok egyenlőségét?

Kutatást végzett. Tekintse meg a következő tesztkészletet (groovy konzolszkript):

@Grab('org.spockframework:spock-core:0.7-groovy-2.0')
@Grab('cglib:cglib-nodep:3.1')

import spock.lang.*

class Test extends Specification {
    def "not comparable mocks are not equal"() {
        given:
        def a1 = Mock(A)
        def a2 = Mock(A)

        expect:
        a1.hashCode() != a2.hashCode()
        !a1.equals(a2)
        !(a1 == a2)        
    }

    def "comparable mocks are not equal"() {
        given:
        def a1 = Mock(AC)
        def a2 = Mock(AC)

        expect:
        a1.hashCode() != a2.hashCode()
        !a1.equals(a2)
        !(a1 == a2)        
    }

    def "cannot create TreeSet when POJOs are not comparable"() {
        given:
        def a1 = Mock(A)
        def a2 = Mock(A)

        and:    
        a1.hashCode() != a2.hashCode()
        !a1.equals(a2)
        !(a1 == a2)     

        when:
        new TreeSet([a1,a2])

        then:
        def e = thrown(ClassCastException)
        e.message.endsWith('cannot be cast to java.lang.Comparable')
    } 

    def "there's a problem with Comparable Mocks"() {
         given:
        def a1 = Mock(AC)
        def a2 = Mock(AC)

        and:    
        a1.hashCode() != a2.hashCode()
        !a1.equals(a2)
        !(a1 == a2)     

        when:
        def s = new TreeSet([a1,a2])

        then:
        s.size() == 2
    }

    def "with HashSet it works as expected"() {
        given:
        def a1 = Mock(AC) 
        def a2 = Mock(AC) 

        and:    
        a1.hashCode() != a2.hashCode()
        !a1.equals(a2)
        !(a1 == a2)     

        when:
        def s = new HashSet([a1,a2])

        then:
        s.size() == 2
    }
}

class A {}

class AC implements Comparable {

    int compareTo(Object o) {
        1 //whatever value may be here, it's not called
    }
}

Általában probléma van azzal, ha egy objektum megvalósítja a Comparable interfészt.

1. Az első teszt azt mutatja, hogy ugyanazon objektumok különböző mockjei eltérő hash kódokkal rendelkeznek, és nem azonosak. Véleményem szerint ez az elvárt viselkedés.
2. A második teszt ugyanazokat a feltételeket ellenőrzi, kivéve azt a tényt, hogy az objektumok Comparable. Nem sikerül. Véleményem szerint ez nem elvárt viselkedés.
3. A harmadik teszt azt szemlélteti, hogy nem lehet TreeSet-et létrehozni nem összehasonlítható POJO-kkal. Elvárt viselkedés.
4. A negyedik teszt az Ön által említett problémát szemlélteti. A két Comparable gúnnyal létrehozott TreeSet mérete várhatóan 2 lesz. Nem sikerül, a méret 1.
5. Az ötödik teszt azt mutatja, hogy a 4-es teszt feltételei teljesülnek, ha HashSet-t használunk.

IMO ez nem a spock-hoz kapcsolódó probléma. Spock a cglib értéket használja a gúnyos objektumokhoz, és itt kell keresni a magyarázatot.

SZERKESZTÉS

Jól működik, ha a compareTo() metódus felül van írva álobjektumok esetén:

@Grab('org.spockframework:spock-core:0.7-groovy-2.0')
@Grab('cglib:cglib-nodep:3.1')

import spock.lang.*

class Test extends Specification {

    def "there's a problem with Comparable Mocks"() {
         given:
        def a1 = Mock(AC) {
            compareTo(_) >> 3145
        }
        def a2 = Mock(AC) {
            compareTo(_) >> 3146
        }

        and:    
        a1.hashCode() != a2.hashCode()
        !a1.equals(a2)
        !(a1 == a2)     

        when:
        def s = new TreeSet([a1,a2])

        then:
        s.size() == 2
    }
}

class AC implements Comparable {

    int compareTo(Object o) {
        1 //whatever value may be here, it's not called
    }
}

Hacsak a equals() metódusa nem csonkolt, egy Mock() csak equals() maga. Azonban Groovy == nem mindig azt jelenti, hogy equals(). Comparables esetén c1.compareTo(c2) == 0-t jelent. Hasonlóképpen, a TreeSet a compareTo() értéket használja equals helyett az egyenlőség meghatározásához. Lehetséges megoldások:

• Csökkentse a mock compareTo() metódusait, hogy megfelelő értékeket adjon vissza.
• Ne használjon TreeSet-t.
• Használjon valós objektumokat, amelyek a compareTo-t megfelelő módon valósítják meg, nem pedig gúnyokat.

PS: Talán a Mock(Comparable) és/vagy a Stub(Comparable) automatikusan implementálja a compareTo-t a equals()-el összhangban álló módon. Tudsz ezzel kapcsolatos ügyet benyújtani?