Mark a few [client message, server response messages] pairs as invalid message response pairs,

Zhen · Zhen · commit 5ea1e698c878 · 2016-07-19T11:21:11.000+02:00
these message pairs are listed as follows:

INIT        &lt;- IGNORED
ACK_FAILURE &lt;- IGNORED
ACK_FAILURE &lt;- FAILURE
RESET       &lt;- IGNORED
RESET       &lt;- FAILURE

In case of seeing such message pairs, raise an unrecoverable error message on client side.
diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java b/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java
@@ -198,8 +198,8 @@ private void ensureNoUnrecoverableError()
     {
         if( connection.hasUnrecoverableErrors() )
         {
-            throw new ClientException( "Cannot run more statements in the current session as unrecoverable errors " +
-                                       "has happened. Please close the currect session and re-run your statement in a" +
+            throw new ClientException( "Cannot run more statements in the current session as an unrecoverable error " +
+                                       "has happened. Please close the current session and re-run your statement in a" +
                                        " new session." );
         }
     }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalStatementResult.java b/driver/src/main/java/org/neo4j/driver/internal/InternalStatementResult.java
@@ -66,32 +66,14 @@ public InternalStatementResult( Connection connection, Statement statement )
 
     private StreamCollector newRunResponseCollector()
     {
-        return new StreamCollector()
+        return new StreamCollector.NoOperationStreamCollector()
         {
             @Override
             public void keys( String[] names )
             {
                 keys = Arrays.asList( names );
             }
 
-            @Override
-            public void record( Value[] fields ) {}
-
-            @Override
-            public void statementType( StatementType type ) {}
-
-            @Override
-            public void statementStatistics( SummaryCounters statistics ) {}
-
-            @Override
-            public void plan( Plan plan ) {}
-
-            @Override
-            public void profile( ProfiledPlan plan ) {}
-
-            @Override
-            public void notifications( List<Notification> notifications ) {}
-
             @Override
             public void done()
             {
@@ -106,11 +88,8 @@ public void done()
     private StreamCollector newPullAllResponseCollector( Statement statement )
     {
         final SummaryBuilder summaryBuilder = new SummaryBuilder( statement );
-        return new StreamCollector()
+        return new StreamCollector.NoOperationStreamCollector()
         {
-            @Override
-            public void keys( String[] names ) {}
-
             @Override
             public void record( Value[] fields )
             {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/connector/ConcurrencyGuardingConnection.java b/driver/src/main/java/org/neo4j/driver/internal/connector/ConcurrencyGuardingConnection.java
@@ -100,12 +100,12 @@ public void pullAll( StreamCollector collector )
     }
 
     @Override
-    public void reset( StreamCollector collector )
+    public void reset()
     {
         try
         {
             markAsInUse();
-            delegate.reset( collector );
+            delegate.reset();
         }
         finally
         {
@@ -114,12 +114,12 @@ public void reset( StreamCollector collector )
     }
 
     @Override
-    public void ackFailure( StreamCollector collector )
+    public void ackFailure()
     {
         try
         {
             markAsInUse();
-            delegate.ackFailure( collector );
+            delegate.ackFailure();
         }
         finally
         {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/connector/socket/SocketClient.java b/driver/src/main/java/org/neo4j/driver/internal/connector/socket/SocketClient.java
@@ -129,9 +129,7 @@ public void receiveOne( SocketResponseHandler handler ) throws IOException
     {
         reader.read( handler );
 
-        // TODO: all the errors come from the following trace should result in the termination of this channel
-        // https://github.com/neo4j/neo4j/blob/3
-        // .0/community/bolt/src/main/java/org/neo4j/bolt/v1/transport/BoltProtocolV1.java#L86
+        // Stop immediately if bolt protocol error happened on the server
         if ( handler.protocolViolationErrorOccurred() )
         {
             stop();
diff --git a/driver/src/main/java/org/neo4j/driver/internal/connector/socket/SocketConnection.java b/driver/src/main/java/org/neo4j/driver/internal/connector/socket/SocketConnection.java
@@ -67,7 +67,7 @@ public SocketConnection( String host, int port, Config config )
     @Override
     public void init( String clientName, Map<String,Value> authToken )
     {
-        queueMessage( new InitMessage( clientName, authToken ), StreamCollector.NO_OP );
+        queueMessage( new InitMessage( clientName, authToken ), StreamCollector.INIT );
         sync();
     }
 
@@ -90,15 +90,15 @@ public void pullAll( StreamCollector collector )
     }
 
     @Override
-    public void reset( StreamCollector collector )
+    public void reset()
     {
-        queueMessage( RESET, collector );
+        queueMessage( RESET, StreamCollector.RESET );
     }
 
     @Override
-    public void ackFailure( StreamCollector collector )
+    public void ackFailure()
     {
-        queueMessage( ACK_FAILURE, collector );
+        queueMessage( ACK_FAILURE, StreamCollector.ACK_FAILURE );
     }
 
     @Override
diff --git a/driver/src/main/java/org/neo4j/driver/internal/connector/socket/SocketResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/connector/socket/SocketResponseHandler.java
@@ -76,7 +76,7 @@ public void handleFailureMessage( String code, String message )
         }
         if ( collector != null )
         {
-            collector.done();
+            collector.doneFailure( error );
         }
     }
 
@@ -90,7 +90,7 @@ public void handleSuccessMessage( Map<String,Value> meta )
         collectPlan( collector, meta.get( "plan" ) );
         collectProfile( collector, meta.get( "profile" ) );
         collectNotifications( collector, meta.get( "notifications" ) );
-        collector.done();
+        collector.doneSuccess();
     }
 
     private void collectNotifications( StreamCollector collector, Value notifications )
@@ -178,7 +178,7 @@ public void handleIgnoredMessage()
         StreamCollector collector = collectors.remove();
         if (collector != null)
         {
-            collector.done();
+            collector.doneIgnored();
         }
     }
 
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/PackStreamMessageFormatV1.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/PackStreamMessageFormatV1.java
@@ -327,7 +327,7 @@ private void packValue( Value value ) throws IOException
                     break;
 
                 default:
-                    throw new UnsupportedOperationException( "Unknown type: " + value );
+                    throw new IOException( "Unknown type: " + value );
             }
         }
 
diff --git a/driver/src/main/java/org/neo4j/driver/internal/pool/PooledConnection.java b/driver/src/main/java/org/neo4j/driver/internal/pool/PooledConnection.java
@@ -124,11 +124,11 @@ public void pullAll( StreamCollector collector )
     }
 
     @Override
-    public void reset( StreamCollector collector )
+    public void reset()
     {
         try
         {
-            delegate.reset( collector );
+            delegate.reset();
         }
         catch ( RuntimeException e )
         {
@@ -137,11 +137,11 @@ public void reset( StreamCollector collector )
     }
 
     @Override
-    public void ackFailure( StreamCollector collector )
+    public void ackFailure()
     {
         try
         {
-            delegate.ackFailure( collector );
+            delegate.ackFailure();
         }
         catch ( RuntimeException e )
         {
@@ -230,7 +230,7 @@ private void onDelegateException( RuntimeException e )
         }
         else
         {
-            ackFailure( StreamCollector.NO_OP );
+            ackFailure();
         }
         if( onError != null )
         {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/pool/PooledConnectionReleaseConsumer.java b/driver/src/main/java/org/neo4j/driver/internal/pool/PooledConnectionReleaseConsumer.java
@@ -88,7 +88,7 @@ else if ( driverStopped.get() )
     boolean validConnection( PooledConnection pooledConnection )
     {
         // once the pooledConn has marked to have unrecoverable errors, there is no way to remove the error
-        // and we should close the conn without bother to reset the conn at all
+        // and we should close the conn without bothering to reset the conn at all
         return !pooledConnection.hasUnrecoverableErrors() &&
                reset(pooledConnection) &&
                (pooledConnection.idleTime() <= minIdleBeforeConnectionTest || ping( pooledConnection ));
@@ -104,7 +104,7 @@ private boolean reset( PooledConnection conn )
     {
         try
         {
-            conn.reset( StreamCollector.NO_OP );
+            conn.reset();
             conn.sync();
             return true;
         }
diff --git a/driver/src/main/java/org/neo4j/driver/internal/spi/Connection.java b/driver/src/main/java/org/neo4j/driver/internal/spi/Connection.java
@@ -55,16 +55,17 @@ public interface Connection extends AutoCloseable
     void pullAll( StreamCollector collector );
 
     /**
-     * Queue a reset action, output will be handed to the collector once the pull starts. This will
+     * Queue a reset action, throw {@link org.neo4j.driver.v1.exceptions.ClientException} if an ignored message is received. This will
      * close the stream once its completed, allowing another {@link #run(String, java.util.Map, StreamCollector) run}
      */
-    void reset( StreamCollector collector );
+    void reset();
 
     /**
-     * Queue a reset action, output will be handed to the collector once the pull starts. This will
-     * close the stream once its completed, allowing another {@link #run(String, java.util.Map, StreamCollector) run}
+     * Queue a ack_failure action, valid output could only be success. Throw {@link org.neo4j.driver.v1.exceptions.ClientException} if
+     * a failure or ignored message is received. This will close the stream once it is completed, allowing another
+     * {@link #run(String, java.util.Map, StreamCollector) run}
      */
-    void ackFailure( StreamCollector collector );
+    void ackFailure();
 
     /**
      * Ensure all outstanding actions are carried out on the server.
diff --git a/driver/src/main/java/org/neo4j/driver/internal/spi/StreamCollector.java b/driver/src/main/java/org/neo4j/driver/internal/spi/StreamCollector.java
@@ -20,16 +20,65 @@
 
 import java.util.List;
 
+import org.neo4j.driver.v1.Value;
+import org.neo4j.driver.v1.exceptions.ClientException;
+import org.neo4j.driver.v1.exceptions.Neo4jException;
 import org.neo4j.driver.v1.summary.Notification;
 import org.neo4j.driver.v1.summary.Plan;
 import org.neo4j.driver.v1.summary.ProfiledPlan;
 import org.neo4j.driver.v1.summary.StatementType;
 import org.neo4j.driver.v1.summary.SummaryCounters;
-import org.neo4j.driver.v1.Value;
 
 public interface StreamCollector
 {
-    StreamCollector NO_OP = new StreamCollector()
+    StreamCollector NO_OP = new NoOperationStreamCollector();
+
+    StreamCollector ACK_FAILURE = new NoOperationStreamCollector()
+    {
+        @Override
+        public void doneFailure( Neo4jException error )
+        {
+            throw new ClientException(
+                    "Invalid server response message `FAILURE` received for client message `ACK_FAILURE`.", error );
+        }
+
+        @Override
+        public void doneIgnored()
+        {
+            throw new ClientException(
+                    "Invalid server response message `IGNORED` received for client message `ACK_FAILURE`." );
+        }
+    };
+
+    StreamCollector INIT = new NoOperationStreamCollector()
+    {
+        @Override
+        public void doneIgnored()
+        {
+            throw new ClientException(
+                    "Invalid server response message `IGNORED` received for client message `INIT`." );
+        }
+    };
+
+
+    StreamCollector RESET = new NoOperationStreamCollector()
+    {
+        @Override
+        public void doneFailure( Neo4jException error )
+        {
+            throw new ClientException(
+                    "Invalid server response message `FAILURE` received for client message `RESET`.", error );
+        }
+
+        @Override
+        public void doneIgnored()
+        {
+            throw new ClientException(
+                    "Invalid server response message `IGNORED` received for client message `RESET`." );
+        }
+    };
+
+    class NoOperationStreamCollector implements StreamCollector
     {
         @Override
         public void keys( String[] names ) {}
@@ -54,7 +103,25 @@ public void notifications( List<Notification> notifications ) {}
 
         @Override
         public void done() {}
-    };
+
+        @Override
+        public void doneSuccess()
+        {
+            done();
+        }
+
+        @Override
+        public void doneFailure( Neo4jException error )
+        {
+            done();
+        }
+
+        @Override
+        public void doneIgnored()
+        {
+            done();
+        }
+    }
 
     // TODO: This should be modified to simply have head/record/tail methods
 
@@ -73,5 +140,11 @@ public void done() {}
     void notifications( List<Notification> notifications );
 
     void done();
+
+    void doneSuccess();
+
+    void doneFailure( Neo4jException error );
+
+    void doneIgnored();
 }
 
diff --git a/driver/src/main/java/org/neo4j/driver/internal/summary/SummaryBuilder.java b/driver/src/main/java/org/neo4j/driver/internal/summary/SummaryBuilder.java
@@ -22,6 +22,7 @@
 import java.util.List;
 
 import org.neo4j.driver.internal.spi.StreamCollector;
+import org.neo4j.driver.v1.exceptions.Neo4jException;
 import org.neo4j.driver.v1.summary.Notification;
 import org.neo4j.driver.v1.summary.Plan;
 import org.neo4j.driver.v1.summary.ProfiledPlan;
@@ -126,6 +127,25 @@ public void notifications( List<Notification> notifications )
     @Override
     public void done()
     {
+        // intentionally empty
+    }
+
+    @Override
+    public void doneSuccess()
+    {
+        // intentionally empty
+    }
+
+    @Override
+    public void doneFailure( Neo4jException erro )
+    {
+        // intentionally empty
+    }
+
+    @Override
+    public void doneIgnored()
+    {
+        // intentionally empty
     }
 
     public ResultSummary build()
diff --git a/driver/src/test/java/org/neo4j/driver/internal/pool/ConnectionInvalidationTest.java b/driver/src/test/java/org/neo4j/driver/internal/pool/ConnectionInvalidationTest.java
@@ -103,7 +103,7 @@ public void shouldNotInvalidateConnectionThatIsNotOld() throws Throwable
     public void shouldInvalidConnectionIfFailedToReset() throws Throwable
     {
         // Given a connection that's broken
-        Mockito.doThrow( new ClientException( "That didn't work" ) ).when( delegate ).reset( any( StreamCollector.class ) );
+        Mockito.doThrow( new ClientException( "That didn't work" ) ).when( delegate ).reset();
         Config config = Config.defaultConfig();
         PooledConnection conn = new PooledConnection( delegate, Consumers.<PooledConnection>noOp(), clock );
 
diff --git a/driver/src/test/java/org/neo4j/driver/internal/pool/PooledConnectionTest.java b/driver/src/test/java/org/neo4j/driver/internal/pool/PooledConnectionTest.java

Original file line number	Diff line number	Diff line change
`@@ -198,8 +198,8 @@ private void ensureNoUnrecoverableError()`
`198`	`198`	`{`
`199`	`199`	`if( connection.hasUnrecoverableErrors() )`
`200`	`200`	`{`
`201`		`- throw new ClientException( "Cannot run more statements in the current session as unrecoverable errors " +`
`202`		`- "has happened. Please close the currect session and re-run your statement in a" +`
	`201`	`+ throw new ClientException( "Cannot run more statements in the current session as an unrecoverable error " +`
	`202`	`+ "has happened. Please close the current session and re-run your statement in a" +`
`203`	`203`	`" new session." );`
`204`	`204`	`}`
`205`	`205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,32 +66,14 @@ public InternalStatementResult( Connection connection, Statement statement )`
`66`	`66`
`67`	`67`	`private StreamCollector newRunResponseCollector()`
`68`	`68`	`{`
`69`		`- return new StreamCollector()`
	`69`	`+ return new StreamCollector.NoOperationStreamCollector()`
`70`	`70`	`{`
`71`	`71`	`@Override`
`72`	`72`	`public void keys( String[] names )`
`73`	`73`	`{`
`74`	`74`	`keys = Arrays.asList( names );`
`75`	`75`	`}`
`76`	`76`
`77`		`- @Override`
`78`		`- public void record( Value[] fields ) {}`
`79`		`-`
`80`		`- @Override`
`81`		`- public void statementType( StatementType type ) {}`
`82`		`-`
`83`		`- @Override`
`84`		`- public void statementStatistics( SummaryCounters statistics ) {}`
`85`		`-`
`86`		`- @Override`
`87`		`- public void plan( Plan plan ) {}`
`88`		`-`
`89`		`- @Override`
`90`		`- public void profile( ProfiledPlan plan ) {}`
`91`		`-`
`92`		`- @Override`
`93`		`- public void notifications( List<Notification> notifications ) {}`
`94`		`-`
`95`	`77`	`@Override`
`96`	`78`	`public void done()`
`97`	`79`	`{`
`@@ -106,11 +88,8 @@ public void done()`
`106`	`88`	`private StreamCollector newPullAllResponseCollector( Statement statement )`
`107`	`89`	`{`
`108`	`90`	`final SummaryBuilder summaryBuilder = new SummaryBuilder( statement );`
`109`		`- return new StreamCollector()`
	`91`	`+ return new StreamCollector.NoOperationStreamCollector()`
`110`	`92`	`{`
`111`		`- @Override`
`112`		`- public void keys( String[] names ) {}`
`113`		`-`
`114`	`93`	`@Override`
`115`	`94`	`public void record( Value[] fields )`
`116`	`95`	`{`
Original file line number	Diff line number	Diff line change
`@@ -100,12 +100,12 @@ public void pullAll( StreamCollector collector )`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`@Override`
`103`		`- public void reset( StreamCollector collector )`
	`103`	`+ public void reset()`
`104`	`104`	`{`
`105`	`105`	`try`
`106`	`106`	`{`
`107`	`107`	`markAsInUse();`
`108`		`- delegate.reset( collector );`
	`108`	`+ delegate.reset();`
`109`	`109`	`}`
`110`	`110`	`finally`
`111`	`111`	`{`
`@@ -114,12 +114,12 @@ public void reset( StreamCollector collector )`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`@Override`
`117`		`- public void ackFailure( StreamCollector collector )`
	`117`	`+ public void ackFailure()`
`118`	`118`	`{`
`119`	`119`	`try`
`120`	`120`	`{`
`121`	`121`	`markAsInUse();`
`122`		`- delegate.ackFailure( collector );`
	`122`	`+ delegate.ackFailure();`
`123`	`123`	`}`
`124`	`124`	`finally`
`125`	`125`	`{`
Original file line number	Diff line number	Diff line change
`@@ -129,9 +129,7 @@ public void receiveOne( SocketResponseHandler handler ) throws IOException`
`129`	`129`	`{`
`130`	`130`	`reader.read( handler );`
`131`	`131`
`132`		`- // TODO: all the errors come from the following trace should result in the termination of this channel`
`133`		`- // https://github.com/neo4j/neo4j/blob/3`
`134`		`- // .0/community/bolt/src/main/java/org/neo4j/bolt/v1/transport/BoltProtocolV1.java#L86`
	`132`	`+ // Stop immediately if bolt protocol error happened on the server`
`135`	`133`	`if ( handler.protocolViolationErrorOccurred() )`
`136`	`134`	`{`
`137`	`135`	`stop();`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public SocketConnection( String host, int port, Config config )`
`67`	`67`	`@Override`
`68`	`68`	`public void init( String clientName, Map<String,Value> authToken )`
`69`	`69`	`{`
`70`		`- queueMessage( new InitMessage( clientName, authToken ), StreamCollector.NO_OP );`
	`70`	`+ queueMessage( new InitMessage( clientName, authToken ), StreamCollector.INIT );`
`71`	`71`	`sync();`
`72`	`72`	`}`
`73`	`73`
`@@ -90,15 +90,15 @@ public void pullAll( StreamCollector collector )`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`@Override`
`93`		`- public void reset( StreamCollector collector )`
	`93`	`+ public void reset()`
`94`	`94`	`{`
`95`		`- queueMessage( RESET, collector );`
	`95`	`+ queueMessage( RESET, StreamCollector.RESET );`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`@Override`
`99`		`- public void ackFailure( StreamCollector collector )`
	`99`	`+ public void ackFailure()`
`100`	`100`	`{`
`101`		`- queueMessage( ACK_FAILURE, collector );`
	`101`	`+ queueMessage( ACK_FAILURE, StreamCollector.ACK_FAILURE );`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ public void handleFailureMessage( String code, String message )`
`76`	`76`	`}`
`77`	`77`	`if ( collector != null )`
`78`	`78`	`{`
`79`		`- collector.done();`
	`79`	`+ collector.doneFailure( error );`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`@@ -90,7 +90,7 @@ public void handleSuccessMessage( Map<String,Value> meta )`
`90`	`90`	`collectPlan( collector, meta.get( "plan" ) );`
`91`	`91`	`collectProfile( collector, meta.get( "profile" ) );`
`92`	`92`	`collectNotifications( collector, meta.get( "notifications" ) );`
`93`		`- collector.done();`
	`93`	`+ collector.doneSuccess();`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`private void collectNotifications( StreamCollector collector, Value notifications )`
`@@ -178,7 +178,7 @@ public void handleIgnoredMessage()`
`178`	`178`	`StreamCollector collector = collectors.remove();`
`179`	`179`	`if (collector != null)`
`180`	`180`	`{`
`181`		`- collector.done();`
	`181`	`+ collector.doneIgnored();`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`
Original file line number	Diff line number	Diff line change
`@@ -327,7 +327,7 @@ private void packValue( Value value ) throws IOException`
`327`	`327`	`break;`
`328`	`328`
`329`	`329`	`default:`
`330`		`- throw new UnsupportedOperationException( "Unknown type: " + value );`
	`330`	`+ throw new IOException( "Unknown type: " + value );`
`331`	`331`	`}`
`332`	`332`	`}`
`333`	`333`
Original file line number	Diff line number	Diff line change
`@@ -124,11 +124,11 @@ public void pullAll( StreamCollector collector )`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`@Override`
`127`		`- public void reset( StreamCollector collector )`
	`127`	`+ public void reset()`
`128`	`128`	`{`
`129`	`129`	`try`
`130`	`130`	`{`
`131`		`- delegate.reset( collector );`
	`131`	`+ delegate.reset();`
`132`	`132`	`}`
`133`	`133`	`catch ( RuntimeException e )`
`134`	`134`	`{`
`@@ -137,11 +137,11 @@ public void reset( StreamCollector collector )`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`@Override`
`140`		`- public void ackFailure( StreamCollector collector )`
	`140`	`+ public void ackFailure()`
`141`	`141`	`{`
`142`	`142`	`try`
`143`	`143`	`{`
`144`		`- delegate.ackFailure( collector );`
	`144`	`+ delegate.ackFailure();`
`145`	`145`	`}`
`146`	`146`	`catch ( RuntimeException e )`
`147`	`147`	`{`
`@@ -230,7 +230,7 @@ private void onDelegateException( RuntimeException e )`
`230`	`230`	`}`
`231`	`231`	`else`
`232`	`232`	`{`
`233`		`- ackFailure( StreamCollector.NO_OP );`
	`233`	`+ ackFailure();`
`234`	`234`	`}`
`235`	`235`	`if( onError != null )`
`236`	`236`	`{`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ else if ( driverStopped.get() )`
`88`	`88`	`boolean validConnection( PooledConnection pooledConnection )`
`89`	`89`	`{`
`90`	`90`	`// once the pooledConn has marked to have unrecoverable errors, there is no way to remove the error`
`91`		`- // and we should close the conn without bother to reset the conn at all`
	`91`	`+ // and we should close the conn without bothering to reset the conn at all`
`92`	`92`	`return !pooledConnection.hasUnrecoverableErrors() &&`
`93`	`93`	`reset(pooledConnection) &&`
`94`	`94`	`(pooledConnection.idleTime() <= minIdleBeforeConnectionTest \|\| ping( pooledConnection ));`
`@@ -104,7 +104,7 @@ private boolean reset( PooledConnection conn )`
`104`	`104`	`{`
`105`	`105`	`try`
`106`	`106`	`{`
`107`		`- conn.reset( StreamCollector.NO_OP );`
	`107`	`+ conn.reset();`
`108`	`108`	`conn.sync();`
`109`	`109`	`return true;`
`110`	`110`	`}`