private static void fullVerification( Maps target, Random random ) { for ( Map.Entry<Long, Integer> entry: target.normalMap.entrySet() ) { assertTrue( target.map.containsKey( entry.getKey() ) ); assertEquals( entry.getValue(), target.map.get( entry.getKey() ) ); } for ( int i = 0; i < target.normalMap.size(); i++ ) { assertFalse( target.map.containsKey( randomNonExisting( random, target.normalMap ) ) ); } }
@Override public String apply( Maps target ) { Integer existingValue = target.normalMap.get( key ); boolean existedBefore = target.map.containsKey( key ); Integer valueBefore = target.map.get( key ); Integer removed = target.map.remove( key ); boolean existsAfter = target.map.containsKey( key ); Integer valueAfter = target.map.get( key ); target.normalMap.remove( key ); boolean existing = existingValue != null; boolean ok = (existedBefore == existing) & (existing ? valueBefore.equals( existingValue ) : valueBefore == null) & (existing ? removed.equals( existingValue ) : removed == null) & (valueAfter == null) & !existsAfter; return ok ? null : "" + key + "," + existingValue + "," + existedBefore + "," + removed + "," + existsAfter; }
@Override public String apply( Maps target ) { Integer existingValue = target.normalMap.get( key ); int actualSizeBefore = target.normalMap.size(); int sizeBefore = target.map.size(); boolean existedBefore = target.map.containsKey( key ); Integer valueBefore = target.map.get( key ); Integer previous = target.map.put( key, value ); boolean existsAfter = target.map.containsKey( key ); Integer valueAfter = target.map.get( key ); target.normalMap.put( key, value ); int sizeAfter = target.map.size(); int actualSizeAfter = target.normalMap.size(); boolean existing = existingValue != null; boolean ok = (sizeBefore == actualSizeBefore) & (existedBefore == existing) & (existing ? existingValue.equals( valueBefore ) : valueBefore == null) & (existing ? previous.equals( existingValue ) : previous == null) & (valueAfter != null && valueAfter.equals( value )) & existsAfter & (sizeAfter == actualSizeAfter); return ok ? null : "" + key + ":" + value + "," + existingValue + "," + existedBefore + "," + previous + "," + existsAfter; }
boolean existedBefore = map.containsKey( 1433091763 ); Integer valueBefore = map.get( 1433091763 ); Integer previous = map.put( 1433091763, 35 ); boolean existsAfter = map.containsKey( 1433091763 ); Integer valueAfter = map.get( 1433091763 ); assertTrue( existedBefore, "1433091763 should exist before putting here" );
@Test void shouldContainAddedValues_2() { // GIVEN PrimitiveLongObjectMap<Integer> map = Primitive.longObjectMap(); map.put( 1950736976, 4 ); map.put( 1054824202, 58 ); map.put( 348690619, 54 ); map.put( 1224909480, 79 ); map.put( 1508493474, 82 ); // WHEN/THEN boolean existedBefore = map.containsKey( 1508493474 ); Integer valueBefore = map.get( 1508493474 ); Integer previous = map.put( 1508493474, 62 ); boolean existsAfter = map.containsKey( 1508493474 ); Integer valueAfter = map.get( 1508493474 ); assertTrue( existedBefore, "1508493474 should exist before putting here" ); assertEquals( (Integer) 82, valueBefore, "value before should be 82" ); assertEquals( (Integer) 82, previous, "value returned from put should be 82" ); assertTrue( existsAfter, "1508493474 should exist" ); assertEquals( (Integer) 62, valueAfter, "value after putting should be 62" ); }
@Test void shouldMoveValuesWhenMovingEntriesAround() { // GIVEN PrimitiveLongObjectMap<Integer> map = Primitive.longObjectMap(); map.put( 206243105, 47 ); map.put( 2083304695, 63 ); map.put( 689837337, 7 ); map.remove( 206243105 ); // WHEN/THEN int sizeBefore = map.size(); boolean existedBefore = map.containsKey( 689837337 ); Integer valueBefore = map.get( 689837337 ); Integer previous = map.put( 689837337, 20 ); boolean existsAfter = map.containsKey( 689837337 ); Integer valueAfter = map.get( 689837337 ); int sizeAfter = map.size(); assertEquals( 2, sizeBefore, "Size before put should have been 2" ); assertTrue( existedBefore, "689837337 should exist before putting here" ); assertEquals( (Integer) 7, valueBefore, "value before should be 7" ); assertEquals( (Integer) 7, previous, "value returned from put should be 7" ); assertTrue( existsAfter, "689837337 should exist" ); assertEquals( (Integer) 20, valueAfter, "value after putting should be 20" ); assertEquals( 2, sizeAfter, "Size after put should have been 2" ); }
map.put( 880140639, 87 ); boolean existedBefore = map.containsKey( 468007595 ); Integer valueBefore = map.get( 468007595 ); Integer previous = map.put( 468007595, 67 ); boolean existsAfter = map.containsKey( 468007595 ); Integer valueAfter = map.get( 468007595 ); assertFalse( existedBefore, "468007595 should not exist before putting here" );
boolean existedBefore = map.containsKey( 679686325 ); Integer valueBefore = map.get( 679686325 ); Integer previous = map.put( 679686325, 63 ); boolean existsAfter = map.containsKey( 679686325 ); Integer valueAfter = map.get( 679686325 ); int sizeAfter = map.size();
public HandshakeOutcome handleVersionHandshakeChunk( ByteBuf buffer, Channel ch ) { if ( suggestedVersions.remaining() > buffer.readableBytes() ) { suggestedVersions.limit( suggestedVersions.position() + buffer.readableBytes() ); buffer.readBytes( suggestedVersions ); suggestedVersions.limit( suggestedVersions.capacity() ); } else { buffer.readBytes( suggestedVersions ); } if ( suggestedVersions.remaining() == 0 ) { suggestedVersions.flip(); for ( int i = 0; i < 4; i++ ) { long suggestion = suggestedVersions.getInt() & 0xFFFFFFFFL; if ( availableVersions.containsKey( suggestion ) ) { protocol = availableVersions.get( suggestion ).apply( ch ); return HandshakeOutcome.PROTOCOL_CHOSEN; } } // None of the suggested protocol versions are available. return HandshakeOutcome.NO_APPLICABLE_PROTOCOL; } return HandshakeOutcome.PARTIAL_HANDSHAKE; }
public HandshakeOutcome handleVersionHandshakeChunk( ByteBuf buffer, Channel ch ) { if ( suggestedVersions.remaining() > buffer.readableBytes() ) { suggestedVersions.limit( suggestedVersions.position() + buffer.readableBytes() ); buffer.readBytes( suggestedVersions ); suggestedVersions.limit( suggestedVersions.capacity() ); } else { buffer.readBytes( suggestedVersions ); } if ( suggestedVersions.remaining() == 0 ) { suggestedVersions.flip(); for ( int i = 0; i < 4; i++ ) { long suggestion = suggestedVersions.getInt() & 0xFFFFFFFFL; if ( availableVersions.containsKey( suggestion ) ) { protocol = availableVersions.get( suggestion ).apply( ch ); return HandshakeOutcome.PROTOCOL_CHOSEN; } } // None of the suggested protocol versions are available. return HandshakeOutcome.NO_APPLICABLE_PROTOCOL; } return HandshakeOutcome.PARTIAL_HANDSHAKE; }
boolean existedBefore = map.containsKey( 5826258075197365143L ); Integer valueBefore = map.get( 5826258075197365143L ); Integer previous = map.put( 5826258075197365143L, 6 ); boolean existsAfter = map.containsKey( 5826258075197365143L ); Integer valueAfter = map.get( 5826258075197365143L ); int sizeAfter = map.size();