def testConses1(): te.checkComplainAndAdjustExpected( 0) c1= ConsSimple( 1, 1) c1.cdr( c1) c2= ConsSimple( 1, 1) c2.cdr( c2) c3= ConsSimple( 1, 1) c3.cdr( c1) c4= ConsSimple( 1, 1) c4.cdr( c3) c5= ConsSimple( 1, 1) c5.cdr( c2) test( True , ConsTrait( c1)==ConsTrait( c2) ) test( False , ConsTrait( c1)==ConsTrait( c3) ) test( False , ConsTrait( c3)==ConsTrait( c1) ) test( True , ConsTrait( c3)==ConsTrait( c3) ) test( False , ConsTrait( c4)==ConsTrait( c3) ) test( True , ConsTrait( c5)==ConsTrait( c3) ) test( False , ConsTrait( c5)==ConsTrait( c4) ) c6_1= ConsSimple( 1, 1) c6_2= ConsSimple( 1, 1) c6_1.cdr( c6_2) c6_2.cdr( c6_1) test( True , ConsTrait( c6_1)==ConsTrait( c6_1) ) test( True , ConsTrait( c6_1)==ConsTrait( c6_2) ) test( True , ConsTrait( c6_2)==ConsTrait( c6_1) ) c7_1= ConsSimple( 1, 1) c7_2= ConsSimple( 1, 1) c7_3= ConsSimple( 1, 1) c7_1.cdr( c7_2) c7_2.cdr( c7_3) c7_3.cdr( c7_1) test( True , ConsTrait( c7_1)==ConsTrait( c7_1) ) ct7_1= ConsTrait( c7_1) ct7_2= ct7_1.cdr() test( True , ct7_2.consWrapped==c7_2 ) test( False , ct7_1==ct7_2 ) test( True , ConsTrait( c7_1)==ConsTrait( c7_2) ) d= dict() test( False , ConsTrait( c7_1, d)==makeConsTrait( c7_2, d) ) del d c8_1= ConsSimple( 1, 1) c8_2= ConsSimple( 1, 1) c8_3= ConsSimple( 1, 1) c8_4= ConsSimple( 1, 1) c8_1.cdr( c8_2) c8_2.cdr( c8_3) c8_3.cdr( c8_4) c8_4.cdr( c8_1) test( True , ConsTrait( c8_1)==ConsTrait( c8_1) ) test( True , ConsTrait( c8_1)==makeConsTrait( c8_2) ) d= dict() test( False , ConsTrait( c8_1, d)==makeConsTrait( c8_2, d) ) del d test( True , ConsTrait( c8_1)==ConsTrait( c8_3) ) test( True , ConsTrait( c8_2)==ConsTrait( c8_4) ) c8_2_clonedDeep= ConsTrait( c8_2).cloneDeep() test( True , ConsTrait( c8_1)==ConsTrait( c8_2_clonedDeep) ) test( True, hash( ConsTrait( c8_1)) == hash( ConsTrait( c8_2_clonedDeep))) # ok, es werden also die symmetrien beachtet, das soll mir recht sein test( True, hash( ConsTrait( c1)) == hash( ConsTrait( c2))) test( False, hash( ConsTrait( c1)) == hash( ConsTrait( c3))) test( True, hash( ConsTrait( c7_1)) == hash( ConsTrait( c7_2))) test( True, hash( ConsTrait( c7_1)) == hash( ConsTrait( c7_3))) test( True, hash( ConsTrait( c8_1)) == hash( ConsTrait( c8_2))) test( True, hash( ConsTrait( c8_1)) == hash( ConsTrait( c8_3))) test( True, hash( ConsTrait( c8_1)) == hash( ConsTrait( c8_4))) te.checkComplainAndAdjustExpected( 29)
def testConsAbstraction1(): # Referenzbeispiel fuer Cons-Abstraktion te.checkComplainAndAdjustExpected( 0) CAS1= makeConsAbstractSwap( ConsSimple) CAS1.__name__= 'CAS1' CAS2= makeConsAbstractSwap( CAS1) CAS2.__name__= 'CAS2' CAS3= makeConsAbstractSwap( CAS2) CAS3.__name__= 'CAS3' CAS4= makeConsAbstractSwap( CAS3) CAS4.__name__= 'CAS4' cs4= CAS4( 1, CAS4( 2, CAS4( 3, nil))) #print ConsTrait( ConsSimple( 1, ConsSimple( 2, ConsSimple( 3, nil)))).repr_wrapped() testCrCr( CAS4( 1, CAS4( 2, CAS4( 3, nil))), cs4) testCrCr( CAS3( CAS3( CAS3( nil, 3), 2), 1), cs4.consWrapped) testCrCr( CAS2( 1, CAS2( 2, CAS2( 3, nil))), cs4.consWrapped.consWrapped) testCrCr( CAS1( CAS1( CAS1( nil, 3), 2), 1), cs4.consWrapped.consWrapped.consWrapped) testCrCr( cs( 1, cs( 2, cs( 3, nil))), cs4.consWrapped.consWrapped.consWrapped.consWrapped) cs4.cdr( CAS4( 4, nil)) test( "CAS4( 1, CAS4( 4, Symbol( 'nil')))", ConsTrait( cs4).repr_wrapped()) testCrCr( CAS4( 1, CAS4( 4, nil)), cs4) testCrCr( cs( 1, cs( 4, nil)), cs4.consWrapped.consWrapped.consWrapped.consWrapped) cs4_2= CAS4.cf.packDeep( ConsSimple( 5, 6)) test( "CAS4( 5, 6)", ConsTrait( cs4_2).repr_wrapped()) test( "CAS3( 6, 5)", ConsTrait( cs4_2.consWrapped).repr_wrapped()) test( "CAS2( 5, 6)", ConsTrait( cs4_2.consWrapped.consWrapped).repr_wrapped()) test( "CAS1( 6, 5)", ConsTrait( cs4_2.consWrapped.consWrapped.consWrapped).repr_wrapped()) test( "ConsSimple( 5, 6)", ConsTrait( cs4_2.consWrapped.consWrapped.consWrapped.consWrapped).repr_wrapped()) test( id( cs4_2.consWrapped), id( cs4_2.cf.unpack( cs4_2))) test( id( cs4_2.consWrapped), id( cs4_2.cf.unpackDeep( cs4_2, CAS3))) test( id( cs4_2.consWrapped.consWrapped), id( cs4_2.cf.unpackDeep( cs4_2, CAS2))) test( id( cs4_2.consWrapped.consWrapped.consWrapped), id( cs4_2.cf.unpackDeep( cs4_2, CAS1))) test( id( cs4_2.consWrapped.consWrapped.consWrapped.consWrapped), id( cs4_2.cf.unpackDeep( cs4_2, ConsSimple))) cs4.cdr().cdr( cs4_2) test( "CAS4( 1, CAS4( 4, CAS4( 5, 6)))", ConsTrait( cs4).repr_wrapped()) test( "ConsSimple( 1, ConsSimple( 4, ConsSimple( 5, 6)))", ConsTrait( cs4.consWrapped.consWrapped.consWrapped.consWrapped).repr_wrapped()) test( ConsTrait( cs4), ConsTrait( cs4.consWrapped.consWrapped.consWrapped.consWrapped)) cs4_cloned= ConsTrait( cs4).cloneDeep() test( "ConsSimple( 1, ConsSimple( 4, ConsSimple( 5, 6)))", ConsTrait( cs4_cloned).repr_wrapped()) test( ConsTrait( cs4), ConsTrait( cs4_cloned)) test( id( cs4.cdr()), id( cs4.cdr())) cs5= ConsSimple( nil, nil) cs5.cdr( cs5) cs6= CAS1.cf.packDeep( cs5) cs7= CAS4.cf.packDeep( cs5) test( id( cs5), id( cs5.cdr())) test( id( cs6), id( cs6.car())) test( id( cs7), id( cs7.cdr())) test( id( cs6), id( CAS1.cf.pack( cs5))) test( id( cs6), id( CAS1.cf.packDeep( cs5))) test( id( cs7), id( CAS4.cf.packDeep( cs5))) test( id( CAS1.cf.packDeep( cs5)), id( CAS1.cf.packDeep( cs5))) test( id( CAS2.cf.pack( cs6)), id( CAS2.cf.pack( cs6))) test( id( CAS2.cf.packDeep( cs6)), id( CAS2.cf.packDeep( cs6))) test( id( CAS2.cf.packDeep( cs5)), id( CAS2.cf.packDeep( cs5))) # baustelle_geloest: nachteil der jetzigen loesung war, dass durch die dynamik immer neue Objekte in den oberen leveln entstehen # Vorteil - der obere Aufbau ist immer ein korrektes Abbild des Unterbaus # Vorteil - die ids sind jetzt eindeutig, wegen nicht mehr immer neuer Objekte und das bedeutet fuer die registrierung in Hash-Tables keine Zuverlaessigkeit # Vorteil - zyklische Datenstrukturen sollten jetzt auch keine unendlichen Views abbilden cs8= CAS4( nil, nil) cs8.cdr( cs8) cs9= cs8.consWrapped.consWrapped.consWrapped.consWrapped test( id( cs9), id( cs9.cdr())) # sogar das geht, prima te.checkComplainAndAdjustExpected( 35)
