You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hc.apache.org by gg...@apache.org on 2017/09/02 20:05:13 UTC
[2/2] httpcomponents-core git commit: Access static methods with the
class that defines them, not a subclass.
Access static methods with the class that defines them, not a subclass.
Project: http://git-wip-us.apache.org/repos/asf/httpcomponents-core/repo
Commit: http://git-wip-us.apache.org/repos/asf/httpcomponents-core/commit/4e99c599
Tree: http://git-wip-us.apache.org/repos/asf/httpcomponents-core/tree/4e99c599
Diff: http://git-wip-us.apache.org/repos/asf/httpcomponents-core/diff/4e99c599
Branch: refs/heads/4.4.x
Commit: 4e99c599b3632f2d625e91593c815ffb4d4bbb7f
Parents: 442d260
Author: Gary Gregory <ga...@gmail.com>
Authored: Sat Sep 2 14:05:08 2017 -0600
Committer: Gary Gregory <ga...@gmail.com>
Committed: Sat Sep 2 14:05:08 2017 -0600
----------------------------------------------------------------------
.../nio/TestDefaultNHttpClientConnection.java | 104 +++++------
.../nio/TestDefaultNHttpServerConnection.java | 104 +++++------
.../http/impl/nio/codecs/TestChunkEncoder.java | 3 +-
.../impl/nio/codecs/TestIdentityEncoder.java | 45 ++---
.../nio/codecs/TestLengthDelimitedEncoder.java | 49 ++---
.../impl/nio/pool/TestBasicNIOConnPool.java | 9 +-
.../apache/http/nio/pool/TestNIOConnPool.java | 187 ++++++++++---------
.../protocol/TestBasicAsyncRequestHandler.java | 3 +-
.../protocol/TestHttpAsyncRequestExecutor.java | 15 +-
.../nio/protocol/TestHttpAsyncRequester.java | 17 +-
.../http/nio/protocol/TestHttpAsyncService.java | 77 ++++----
11 files changed, 311 insertions(+), 302 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpClientConnection.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpClientConnection.java b/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpClientConnection.java
index 374963e..3cb35d2 100644
--- a/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpClientConnection.java
+++ b/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpClientConnection.java
@@ -180,7 +180,7 @@ public class TestDefaultNHttpClientConnection {
Assert.assertEquals(19, conn.outbuf.length());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -205,7 +205,7 @@ public class TestDefaultNHttpClientConnection {
Assert.assertEquals(19, conn.outbuf.length());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -227,10 +227,10 @@ public class TestDefaultNHttpClientConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new RequestReadyAnswer(request)).when(
- handler).requestReady(Mockito.<NHttpClientConnection>any());
+ handler).requestReady(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -252,10 +252,10 @@ public class TestDefaultNHttpClientConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new RequestReadyAnswer(request)).when(
- handler).requestReady(Mockito.<NHttpClientConnection>any());
+ handler).requestReady(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -277,10 +277,10 @@ public class TestDefaultNHttpClientConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new RequestReadyAnswer(request)).when(
- handler).requestReady(Mockito.<NHttpClientConnection>any());
+ handler).requestReady(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -305,10 +305,10 @@ public class TestDefaultNHttpClientConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new RequestReadyAnswer(request)).when(
- handler).requestReady(Mockito.<NHttpClientConnection>any());
+ handler).requestReady(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -335,10 +335,10 @@ public class TestDefaultNHttpClientConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new RequestReadyAnswer(request)).when(
- handler).requestReady(Mockito.<NHttpClientConnection>any());
+ handler).requestReady(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -365,10 +365,10 @@ public class TestDefaultNHttpClientConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new RequestReadyAnswer(request)).when(
- handler).requestReady(Mockito.<NHttpClientConnection>any());
+ handler).requestReady(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -403,9 +403,9 @@ public class TestDefaultNHttpClientConnection {
Mockito.verify(session, Mockito.times(1)).close();
Mockito.verify(session, Mockito.never()).clearEvent(SelectionKey.OP_WRITE);
Mockito.verify(handler, Mockito.never()).requestReady(
- Mockito.<NHttpClientConnection>any());
+ Matchers.<NHttpClientConnection>any());
Mockito.verify(handler, Mockito.never()).outputReady(
- Mockito.<NHttpClientConnection>any(), Mockito.<ContentEncoder>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<ContentEncoder>any());
}
static class ResponseCapturingAnswer implements Answer<Void> {
@@ -462,9 +462,9 @@ public class TestDefaultNHttpClientConnection {
final LinkedList<HttpResponse> responses = new LinkedList<HttpResponse>();
Mockito.doAnswer(new ResponseCapturingAnswer(responses)).when(
- handler).responseReceived(Mockito.<NHttpClientConnection>any());
+ handler).responseReceived(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ConsumeContentAnswer(new SimpleInputBuffer(64))).when(
- handler).inputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentDecoder>any());
+ handler).inputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentDecoder>any());
Assert.assertEquals(0, conn.getMetrics().getResponseCount());
@@ -476,12 +476,12 @@ public class TestDefaultNHttpClientConnection {
Assert.assertEquals(43, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.times(1)).responseReceived(
- Mockito.<NHttpClientConnection>any());
+ Matchers.<NHttpClientConnection>any());
Mockito.verify(handler, Mockito.times(1)).inputReady(
- Mockito.<NHttpClientConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(2)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(2)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpClientConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<Exception>any());
Assert.assertFalse(responses.isEmpty());
final HttpResponse response = responses.getFirst();
@@ -507,9 +507,9 @@ public class TestDefaultNHttpClientConnection {
final LinkedList<HttpResponse> responses = new LinkedList<HttpResponse>();
Mockito.doAnswer(new ResponseCapturingAnswer(responses)).when(
- handler).responseReceived(Mockito.<NHttpClientConnection>any());
+ handler).responseReceived(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ConsumeContentAnswer(new SimpleInputBuffer(64))).when(
- handler).inputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentDecoder>any());
+ handler).inputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentDecoder>any());
Assert.assertEquals(0, conn.getMetrics().getResponseCount());
@@ -521,12 +521,12 @@ public class TestDefaultNHttpClientConnection {
Assert.assertEquals(54, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.times(1)).responseReceived(
- Mockito.<NHttpClientConnection>any());
+ Matchers.<NHttpClientConnection>any());
Mockito.verify(handler, Mockito.times(1)).inputReady(
- Mockito.<NHttpClientConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(2)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(2)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpClientConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<Exception>any());
Assert.assertFalse(responses.isEmpty());
final HttpResponse response = responses.getFirst();
@@ -543,9 +543,9 @@ public class TestDefaultNHttpClientConnection {
Assert.assertEquals(1, conn.getMetrics().getResponseCount());
Assert.assertEquals(54, conn.getMetrics().getReceivedBytesCount());
- Mockito.verify(rchannel, Mockito.times(3)).read(Mockito.<ByteBuffer>any());
+ Mockito.verify(rchannel, Mockito.times(3)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpClientConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<Exception>any());
}
@Test
@@ -559,9 +559,9 @@ public class TestDefaultNHttpClientConnection {
final LinkedList<HttpResponse> responses = new LinkedList<HttpResponse>();
Mockito.doAnswer(new ResponseCapturingAnswer(responses)).when(
- handler).responseReceived(Mockito.<NHttpClientConnection>any());
+ handler).responseReceived(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ConsumeContentAnswer(new SimpleInputBuffer(64))).when(
- handler).inputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentDecoder>any());
+ handler).inputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentDecoder>any());
conn.consumeInput(handler);
@@ -569,12 +569,12 @@ public class TestDefaultNHttpClientConnection {
Assert.assertNull(conn.contentDecoder);
Mockito.verify(handler, Mockito.times(1)).responseReceived(
- Mockito.<NHttpClientConnection>any());
+ Matchers.<NHttpClientConnection>any());
Mockito.verify(handler, Mockito.never()).inputReady(
- Mockito.<NHttpClientConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(1)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(1)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpClientConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<Exception>any());
Assert.assertFalse(responses.isEmpty());
final HttpResponse response = responses.getFirst();
@@ -597,9 +597,9 @@ public class TestDefaultNHttpClientConnection {
final LinkedList<HttpResponse> responses = new LinkedList<HttpResponse>();
Mockito.doAnswer(new ResponseCapturingAnswer(responses)).when(
- handler).responseReceived(Mockito.<NHttpClientConnection>any());
+ handler).responseReceived(Matchers.<NHttpClientConnection>any());
Mockito.doAnswer(new ConsumeContentAnswer(new SimpleInputBuffer(64))).when(
- handler).inputReady(Mockito.<NHttpClientConnection>any(), Mockito.<ContentDecoder>any());
+ handler).inputReady(Matchers.<NHttpClientConnection>any(), Matchers.<ContentDecoder>any());
Assert.assertEquals(0, conn.getMetrics().getResponseCount());
@@ -611,12 +611,12 @@ public class TestDefaultNHttpClientConnection {
Assert.assertEquals(0, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.never()).responseReceived(
- Mockito.<NHttpClientConnection>any());
+ Matchers.<NHttpClientConnection>any());
Mockito.verify(handler, Mockito.never()).inputReady(
- Mockito.<NHttpClientConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(1)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(1)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpClientConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<Exception>any());
conn.consumeInput(handler);
@@ -626,12 +626,12 @@ public class TestDefaultNHttpClientConnection {
Assert.assertEquals(0, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.never()).responseReceived(
- Mockito.<NHttpClientConnection>any());
+ Matchers.<NHttpClientConnection>any());
Mockito.verify(handler, Mockito.never()).inputReady(
- Mockito.<NHttpClientConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(2)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(2)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpClientConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<Exception>any());
conn.consumeInput(handler);
Assert.assertNull(conn.getHttpResponse());
@@ -640,14 +640,14 @@ public class TestDefaultNHttpClientConnection {
Assert.assertEquals(0, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.never()).responseReceived(
- Mockito.<NHttpClientConnection>any());
+ Matchers.<NHttpClientConnection>any());
Mockito.verify(handler, Mockito.never()).inputReady(
- Mockito.<NHttpClientConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(3)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(3)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.times(1)).endOfInput(
- Mockito.<NHttpClientConnection>any());
+ Matchers.<NHttpClientConnection>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpClientConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpClientConnection>any(), Matchers.<Exception>any());
}
@@ -662,7 +662,7 @@ public class TestDefaultNHttpClientConnection {
conn.close();
conn.consumeInput(handler);
- Mockito.verify(rchannel, Mockito.never()).read(Mockito.<ByteBuffer>any());
+ Mockito.verify(rchannel, Mockito.never()).read(Matchers.<ByteBuffer>any());
Mockito.verify(session, Mockito.times(1)).clearEvent(SelectionKey.OP_READ);
}
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpServerConnection.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpServerConnection.java b/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpServerConnection.java
index 08cd498..7887683 100644
--- a/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpServerConnection.java
+++ b/httpcore-nio/src/test/java/org/apache/http/impl/nio/TestDefaultNHttpServerConnection.java
@@ -180,7 +180,7 @@ public class TestDefaultNHttpServerConnection {
Assert.assertEquals(19, conn.outbuf.length());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -205,7 +205,7 @@ public class TestDefaultNHttpServerConnection {
Assert.assertEquals(19, conn.outbuf.length());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -227,10 +227,10 @@ public class TestDefaultNHttpServerConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new ResponseReadyAnswer(response)).when(
- handler).responseReady(Mockito.<NHttpServerConnection>any());
+ handler).responseReady(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -252,10 +252,10 @@ public class TestDefaultNHttpServerConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new ResponseReadyAnswer(response)).when(
- handler).responseReady(Mockito.<NHttpServerConnection>any());
+ handler).responseReady(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -277,10 +277,10 @@ public class TestDefaultNHttpServerConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new ResponseReadyAnswer(response)).when(
- handler).responseReady(Mockito.<NHttpServerConnection>any());
+ handler).responseReady(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -305,10 +305,10 @@ public class TestDefaultNHttpServerConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new ResponseReadyAnswer(response)).when(
- handler).responseReady(Mockito.<NHttpServerConnection>any());
+ handler).responseReady(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -335,10 +335,10 @@ public class TestDefaultNHttpServerConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new ResponseReadyAnswer(response)).when(
- handler).responseReady(Mockito.<NHttpServerConnection>any());
+ handler).responseReady(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -365,10 +365,10 @@ public class TestDefaultNHttpServerConnection {
Mockito.when(session.channel()).thenReturn(channel);
Mockito.doAnswer(new ResponseReadyAnswer(response)).when(
- handler).responseReady(Mockito.<NHttpServerConnection>any());
+ handler).responseReady(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ProduceContentAnswer(entity)).when(
- handler).outputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentEncoder>any());
+ handler).outputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentEncoder>any());
conn.produceOutput(handler);
@@ -403,9 +403,9 @@ public class TestDefaultNHttpServerConnection {
Mockito.verify(session, Mockito.times(1)).close();
Mockito.verify(session, Mockito.never()).clearEvent(SelectionKey.OP_WRITE);
Mockito.verify(handler, Mockito.never()).responseReady(
- Mockito.<NHttpServerConnection>any());
+ Matchers.<NHttpServerConnection>any());
Mockito.verify(handler, Mockito.never()).outputReady(
- Mockito.<NHttpServerConnection>any(), Mockito.<ContentEncoder>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<ContentEncoder>any());
}
static class RequestCapturingAnswer implements Answer<Void> {
@@ -462,9 +462,9 @@ public class TestDefaultNHttpServerConnection {
final LinkedList<HttpRequest> requests = new LinkedList<HttpRequest>();
Mockito.doAnswer(new RequestCapturingAnswer(requests)).when(
- handler).requestReceived(Mockito.<NHttpServerConnection>any());
+ handler).requestReceived(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ConsumeContentAnswer(new SimpleInputBuffer(64))).when(
- handler).inputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentDecoder>any());
+ handler).inputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentDecoder>any());
Assert.assertEquals(0, conn.getMetrics().getRequestCount());
@@ -476,12 +476,12 @@ public class TestDefaultNHttpServerConnection {
Assert.assertEquals(43, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.times(1)).requestReceived(
- Mockito.<NHttpServerConnection>any());
+ Matchers.<NHttpServerConnection>any());
Mockito.verify(handler, Mockito.times(1)).inputReady(
- Mockito.<NHttpServerConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(2)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(2)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpServerConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<Exception>any());
Assert.assertFalse(requests.isEmpty());
final HttpRequest request = requests.getFirst();
@@ -508,9 +508,9 @@ public class TestDefaultNHttpServerConnection {
final LinkedList<HttpRequest> requests = new LinkedList<HttpRequest>();
Mockito.doAnswer(new RequestCapturingAnswer(requests)).when(
- handler).requestReceived(Mockito.<NHttpServerConnection>any());
+ handler).requestReceived(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ConsumeContentAnswer(new SimpleInputBuffer(64))).when(
- handler).inputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentDecoder>any());
+ handler).inputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentDecoder>any());
Assert.assertEquals(0, conn.getMetrics().getResponseCount());
@@ -522,12 +522,12 @@ public class TestDefaultNHttpServerConnection {
Assert.assertEquals(54, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.times(1)).requestReceived(
- Mockito.<NHttpServerConnection>any());
+ Matchers.<NHttpServerConnection>any());
Mockito.verify(handler, Mockito.times(1)).inputReady(
- Mockito.<NHttpServerConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(2)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(2)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpServerConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<Exception>any());
Assert.assertFalse(requests.isEmpty());
final HttpRequest request = requests.getFirst();
@@ -545,9 +545,9 @@ public class TestDefaultNHttpServerConnection {
Assert.assertEquals(1, conn.getMetrics().getRequestCount());
Assert.assertEquals(54, conn.getMetrics().getReceivedBytesCount());
- Mockito.verify(rchannel, Mockito.times(3)).read(Mockito.<ByteBuffer>any());
+ Mockito.verify(rchannel, Mockito.times(3)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpServerConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<Exception>any());
}
@Test
@@ -561,9 +561,9 @@ public class TestDefaultNHttpServerConnection {
final LinkedList<HttpRequest> requests = new LinkedList<HttpRequest>();
Mockito.doAnswer(new RequestCapturingAnswer(requests)).when(
- handler).requestReceived(Mockito.<NHttpServerConnection>any());
+ handler).requestReceived(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ConsumeContentAnswer(new SimpleInputBuffer(64))).when(
- handler).inputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentDecoder>any());
+ handler).inputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentDecoder>any());
conn.consumeInput(handler);
@@ -571,12 +571,12 @@ public class TestDefaultNHttpServerConnection {
Assert.assertNull(conn.contentDecoder);
Mockito.verify(handler, Mockito.times(1)).requestReceived(
- Mockito.<NHttpServerConnection>any());
+ Matchers.<NHttpServerConnection>any());
Mockito.verify(handler, Mockito.never()).inputReady(
- Mockito.<NHttpServerConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(1)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(1)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpServerConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<Exception>any());
Assert.assertFalse(requests.isEmpty());
final HttpRequest request = requests.getFirst();
@@ -599,9 +599,9 @@ public class TestDefaultNHttpServerConnection {
final LinkedList<HttpRequest> requests = new LinkedList<HttpRequest>();
Mockito.doAnswer(new RequestCapturingAnswer(requests)).when(
- handler).requestReceived(Mockito.<NHttpServerConnection>any());
+ handler).requestReceived(Matchers.<NHttpServerConnection>any());
Mockito.doAnswer(new ConsumeContentAnswer(new SimpleInputBuffer(64))).when(
- handler).inputReady(Mockito.<NHttpServerConnection>any(), Mockito.<ContentDecoder>any());
+ handler).inputReady(Matchers.<NHttpServerConnection>any(), Matchers.<ContentDecoder>any());
Assert.assertEquals(0, conn.getMetrics().getResponseCount());
@@ -613,12 +613,12 @@ public class TestDefaultNHttpServerConnection {
Assert.assertEquals(0, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.never()).requestReceived(
- Mockito.<NHttpServerConnection>any());
+ Matchers.<NHttpServerConnection>any());
Mockito.verify(handler, Mockito.never()).inputReady(
- Mockito.<NHttpServerConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(1)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(1)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpServerConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<Exception>any());
conn.consumeInput(handler);
@@ -628,12 +628,12 @@ public class TestDefaultNHttpServerConnection {
Assert.assertEquals(0, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.never()).requestReceived(
- Mockito.<NHttpServerConnection>any());
+ Matchers.<NHttpServerConnection>any());
Mockito.verify(handler, Mockito.never()).inputReady(
- Mockito.<NHttpServerConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(2)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(2)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpServerConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<Exception>any());
conn.consumeInput(handler);
Assert.assertNull(conn.getHttpResponse());
@@ -642,14 +642,14 @@ public class TestDefaultNHttpServerConnection {
Assert.assertEquals(0, conn.getMetrics().getReceivedBytesCount());
Mockito.verify(handler, Mockito.never()).requestReceived(
- Mockito.<NHttpServerConnection>any());
+ Matchers.<NHttpServerConnection>any());
Mockito.verify(handler, Mockito.never()).inputReady(
- Mockito.<NHttpServerConnection>any(), Mockito.<LengthDelimitedDecoder>any());
- Mockito.verify(rchannel, Mockito.times(3)).read(Mockito.<ByteBuffer>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<LengthDelimitedDecoder>any());
+ Mockito.verify(rchannel, Mockito.times(3)).read(Matchers.<ByteBuffer>any());
Mockito.verify(handler, Mockito.times(1)).endOfInput(
- Mockito.<NHttpServerConnection>any());
+ Matchers.<NHttpServerConnection>any());
Mockito.verify(handler, Mockito.never()).exception(
- Mockito.<NHttpServerConnection>any(), Mockito.<Exception>any());
+ Matchers.<NHttpServerConnection>any(), Matchers.<Exception>any());
}
@@ -664,7 +664,7 @@ public class TestDefaultNHttpServerConnection {
conn.close();
conn.consumeInput(handler);
- Mockito.verify(rchannel, Mockito.never()).read(Mockito.<ByteBuffer>any());
+ Mockito.verify(rchannel, Mockito.never()).read(Matchers.<ByteBuffer>any());
Mockito.verify(session, Mockito.times(1)).clearEvent(SelectionKey.OP_READ);
}
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestChunkEncoder.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestChunkEncoder.java b/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestChunkEncoder.java
index 2f17738..d63f2d6 100644
--- a/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestChunkEncoder.java
+++ b/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestChunkEncoder.java
@@ -36,6 +36,7 @@ import org.apache.http.impl.nio.reactor.SessionOutputBufferImpl;
import org.apache.http.nio.reactor.SessionOutputBuffer;
import org.junit.Assert;
import org.junit.Test;
+import org.mockito.Matchers;
import org.mockito.Mockito;
/**
@@ -125,7 +126,7 @@ public class TestChunkEncoder {
Assert.assertEquals(16, encoder.write(CodecTestUtils.wrap("0123456789ABCDEF")));
Assert.assertEquals(16, encoder.write(CodecTestUtils.wrap("0123456789ABCDEF")));
- Mockito.verify(channel, Mockito.never()).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.never()).write(Matchers.<ByteBuffer>any());
outbuf.flush(channel);
final String s = channel.dump(Consts.ASCII);
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestIdentityEncoder.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestIdentityEncoder.java b/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestIdentityEncoder.java
index c7fc6ba..ccdcb5e 100644
--- a/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestIdentityEncoder.java
+++ b/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestIdentityEncoder.java
@@ -41,6 +41,7 @@ import org.apache.http.nio.reactor.SessionOutputBuffer;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
+import org.mockito.Matchers;
import org.mockito.Mockito;
/**
@@ -311,8 +312,8 @@ public class TestIdentityEncoder {
final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 0);
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
- Mockito.verify(channel, Mockito.times(2)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.never()).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(2)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.never()).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(13, metrics.getBytesTransferred());
@@ -333,8 +334,8 @@ public class TestIdentityEncoder {
final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 32);
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
- Mockito.verify(channel, Mockito.never()).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(1)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.never()).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(1)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.never()).flush(channel);
Assert.assertEquals(0, metrics.getBytesTransferred());
@@ -356,8 +357,8 @@ public class TestIdentityEncoder {
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.never()).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.never()).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.never()).flush(channel);
Assert.assertEquals(0, metrics.getBytesTransferred());
@@ -378,8 +379,8 @@ public class TestIdentityEncoder {
final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 2);
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
- Mockito.verify(channel, Mockito.times(2)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.never()).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(2)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.never()).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(13, metrics.getBytesTransferred());
@@ -402,8 +403,8 @@ public class TestIdentityEncoder {
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.times(5)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(5)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(3)).flush(channel);
Assert.assertEquals(18, metrics.getBytesTransferred());
@@ -427,8 +428,8 @@ public class TestIdentityEncoder {
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.times(4)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(4)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(2)).flush(channel);
Assert.assertEquals(18, metrics.getBytesTransferred());
@@ -454,8 +455,8 @@ public class TestIdentityEncoder {
Assert.assertEquals(2, encoder.write(CodecTestUtils.wrap("--")));
Assert.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.times(4)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(5)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(4)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(5)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(2)).flush(channel);
Assert.assertEquals(21, metrics.getBytesTransferred());
@@ -476,8 +477,8 @@ public class TestIdentityEncoder {
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
Assert.assertEquals(6, encoder.write(CodecTestUtils.wrap("-stuff")));
- Mockito.verify(channel, Mockito.times(1)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(1)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(8, metrics.getBytesTransferred());
@@ -499,8 +500,8 @@ public class TestIdentityEncoder {
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
Assert.assertEquals(16, encoder.write(CodecTestUtils.wrap("-much more stuff")));
- Mockito.verify(channel, Mockito.times(2)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(1)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(2)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(1)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(21, metrics.getBytesTransferred());
@@ -529,8 +530,8 @@ public class TestIdentityEncoder {
Assert.assertEquals(0, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(0, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.times(5)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(6)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(5)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(6)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(4)).flush(channel);
Assert.assertEquals(8, metrics.getBytesTransferred());
@@ -554,8 +555,8 @@ public class TestIdentityEncoder {
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("much more stuff")));
- Mockito.verify(channel, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(8, metrics.getBytesTransferred());
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestLengthDelimitedEncoder.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestLengthDelimitedEncoder.java b/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestLengthDelimitedEncoder.java
index ca83ee4..71e0515 100644
--- a/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestLengthDelimitedEncoder.java
+++ b/httpcore-nio/src/test/java/org/apache/http/impl/nio/codecs/TestLengthDelimitedEncoder.java
@@ -41,6 +41,7 @@ import org.apache.http.nio.reactor.SessionOutputBuffer;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
+import org.mockito.Matchers;
import org.mockito.Mockito;
/**
@@ -370,8 +371,8 @@ public class TestLengthDelimitedEncoder {
100, 0);
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
- Mockito.verify(channel, Mockito.times(2)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.never()).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(2)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.never()).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(13, metrics.getBytesTransferred());
@@ -393,8 +394,8 @@ public class TestLengthDelimitedEncoder {
100, 32);
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
- Mockito.verify(channel, Mockito.never()).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(1)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.never()).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(1)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.never()).flush(channel);
Assert.assertEquals(0, metrics.getBytesTransferred());
@@ -417,8 +418,8 @@ public class TestLengthDelimitedEncoder {
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.never()).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.never()).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.never()).flush(channel);
Assert.assertEquals(0, metrics.getBytesTransferred());
@@ -441,8 +442,8 @@ public class TestLengthDelimitedEncoder {
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff; and a lot more stuff")));
- Mockito.verify(channel, Mockito.never()).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.never()).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.never()).flush(channel);
Assert.assertEquals(0, metrics.getBytesTransferred());
@@ -464,8 +465,8 @@ public class TestLengthDelimitedEncoder {
100, 2);
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
- Mockito.verify(channel, Mockito.times(2)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.never()).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(2)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.never()).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(13, metrics.getBytesTransferred());
@@ -489,8 +490,8 @@ public class TestLengthDelimitedEncoder {
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.times(5)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(5)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(3)).flush(channel);
Assert.assertEquals(18, metrics.getBytesTransferred());
@@ -515,8 +516,8 @@ public class TestLengthDelimitedEncoder {
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.times(4)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(4)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(2)).flush(channel);
Assert.assertEquals(18, metrics.getBytesTransferred());
@@ -543,8 +544,8 @@ public class TestLengthDelimitedEncoder {
Assert.assertEquals(2, encoder.write(CodecTestUtils.wrap("--")));
Assert.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.times(4)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(5)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(4)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(5)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(2)).flush(channel);
Assert.assertEquals(21, metrics.getBytesTransferred());
@@ -566,8 +567,8 @@ public class TestLengthDelimitedEncoder {
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
Assert.assertEquals(6, encoder.write(CodecTestUtils.wrap("-stuff")));
- Mockito.verify(channel, Mockito.times(1)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(1)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(8, metrics.getBytesTransferred());
@@ -590,8 +591,8 @@ public class TestLengthDelimitedEncoder {
Assert.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff")));
Assert.assertEquals(16, encoder.write(CodecTestUtils.wrap("-much more stuff")));
- Mockito.verify(channel, Mockito.times(2)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(1)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(2)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(1)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(21, metrics.getBytesTransferred());
@@ -621,8 +622,8 @@ public class TestLengthDelimitedEncoder {
Assert.assertEquals(0, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(0, encoder.write(CodecTestUtils.wrap("more stuff")));
- Mockito.verify(channel, Mockito.times(5)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(6)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(5)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(6)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(4)).flush(channel);
Assert.assertEquals(8, metrics.getBytesTransferred());
@@ -647,8 +648,8 @@ public class TestLengthDelimitedEncoder {
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("-")));
Assert.assertEquals(1, encoder.write(CodecTestUtils.wrap("much more stuff")));
- Mockito.verify(channel, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
- Mockito.verify(outbuf, Mockito.times(3)).write(Mockito.<ByteBuffer>any());
+ Mockito.verify(channel, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
+ Mockito.verify(outbuf, Mockito.times(3)).write(Matchers.<ByteBuffer>any());
Mockito.verify(outbuf, Mockito.times(1)).flush(channel);
Assert.assertEquals(8, metrics.getBytesTransferred());
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/impl/nio/pool/TestBasicNIOConnPool.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/impl/nio/pool/TestBasicNIOConnPool.java b/httpcore-nio/src/test/java/org/apache/http/impl/nio/pool/TestBasicNIOConnPool.java
index 7b58374..78f9cdc 100644
--- a/httpcore-nio/src/test/java/org/apache/http/impl/nio/pool/TestBasicNIOConnPool.java
+++ b/httpcore-nio/src/test/java/org/apache/http/impl/nio/pool/TestBasicNIOConnPool.java
@@ -38,6 +38,7 @@ import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
@@ -113,10 +114,10 @@ public class TestBasicNIOConnPool {
Mockito.when(sessionRequest.getSession()).thenReturn(session);
Mockito.when(sessionRequest.getAttachment()).thenReturn(host);
Mockito.when(reactor.connect(
- Mockito.any(SocketAddress.class),
- Mockito.any(SocketAddress.class),
- Mockito.eq(host),
- Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class),
+ Matchers.any(SocketAddress.class),
+ Matchers.eq(host),
+ Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest);
Mockito.when(session.getSocketTimeout()).thenReturn(999);
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/nio/pool/TestNIOConnPool.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/nio/pool/TestNIOConnPool.java b/httpcore-nio/src/test/java/org/apache/http/nio/pool/TestNIOConnPool.java
index 1cb357e..65d1f44 100644
--- a/httpcore-nio/src/test/java/org/apache/http/nio/pool/TestNIOConnPool.java
+++ b/httpcore-nio/src/test/java/org/apache/http/nio/pool/TestNIOConnPool.java
@@ -47,6 +47,7 @@ import org.apache.http.pool.PoolEntry;
import org.apache.http.pool.PoolStats;
import org.junit.Assert;
import org.junit.Test;
+import org.mockito.Matchers;
import org.mockito.Mockito;
public class TestNIOConnPool {
@@ -173,9 +174,9 @@ public class TestNIOConnPool {
Mockito.when(sessionRequest.getSession()).thenReturn(iosession);
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.any(SocketAddress.class),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 10);
final Future<LocalPoolEntry> future = pool.lease("somehost", null, 100, TimeUnit.MILLISECONDS, null);
@@ -206,9 +207,9 @@ public class TestNIOConnPool {
Mockito.when(sessionRequest.getException()).thenReturn(new IOException());
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.any(SocketAddress.class),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 10);
final Future<LocalPoolEntry> future = pool.lease("somehost", null);
@@ -243,9 +244,9 @@ public class TestNIOConnPool {
Mockito.when(sessionRequest.getSession()).thenReturn(iosession);
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.any(SocketAddress.class),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest);
Mockito.when(ioreactor.getStatus()).thenReturn(IOReactorStatus.ACTIVE);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 10);
@@ -280,9 +281,9 @@ public class TestNIOConnPool {
Mockito.when(sessionRequest.getSession()).thenReturn(iosession);
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.any(SocketAddress.class),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 10);
final Future<LocalPoolEntry> future = pool.lease("somehost", null);
@@ -345,14 +346,14 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1);
Mockito.when(ioreactor.connect(
- Mockito.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest2);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 10);
@@ -419,14 +420,14 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1);
Mockito.when(ioreactor.connect(
- Mockito.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest2);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 10);
@@ -478,8 +479,8 @@ public class TestNIOConnPool {
Assert.assertFalse(future9.isDone());
Mockito.verify(ioreactor, Mockito.times(3)).connect(
- Mockito.any(SocketAddress.class), Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.any(SocketAddress.class), Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
pool.release(entry4, true);
pool.release(entry5, false);
@@ -490,8 +491,8 @@ public class TestNIOConnPool {
Assert.assertTrue(future9.isDone());
Mockito.verify(ioreactor, Mockito.times(4)).connect(
- Mockito.any(SocketAddress.class), Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.any(SocketAddress.class), Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
}
@Test
@@ -518,14 +519,14 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1, sessionRequest2, sessionRequest1);
Mockito.when(ioreactor.connect(
- Mockito.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest3, sessionRequest4, sessionRequest3);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 10);
@@ -539,14 +540,14 @@ public class TestNIOConnPool {
final Future<LocalPoolEntry> future4 = pool.lease("otherhost", null);
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
Mockito.verify(ioreactor, Mockito.never()).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
pool.requestCompleted(sessionRequest1);
pool.requestCompleted(sessionRequest2);
@@ -570,14 +571,14 @@ public class TestNIOConnPool {
pool.release(entry2, true);
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
pool.requestCompleted(sessionRequest3);
pool.requestCompleted(sessionRequest4);
@@ -598,27 +599,27 @@ public class TestNIOConnPool {
final Future<LocalPoolEntry> future6 = pool.lease("otherhost", null);
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
pool.release(entry3, true);
pool.release(entry4, true);
Mockito.verify(ioreactor, Mockito.times(3)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
pool.requestCompleted(sessionRequest1);
@@ -638,14 +639,14 @@ public class TestNIOConnPool {
pool.release(entry6, true);
Mockito.verify(ioreactor, Mockito.times(3)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("otherhost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
totals = pool.getTotalStats();
Assert.assertEquals(2, totals.getAvailable());
@@ -672,9 +673,9 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1, sessionRequest2, sessionRequest3);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 10);
@@ -685,9 +686,9 @@ public class TestNIOConnPool {
final Future<LocalPoolEntry> future2 = pool.lease("somehost", null);
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
pool.requestCompleted(sessionRequest1);
pool.requestCompleted(sessionRequest2);
@@ -720,9 +721,9 @@ public class TestNIOConnPool {
Assert.assertNotNull(entry4);
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
pool.release(entry3, true);
pool.release(entry4, true);
@@ -737,9 +738,9 @@ public class TestNIOConnPool {
Assert.assertFalse(future5.isDone());
Mockito.verify(ioreactor, Mockito.times(3)).connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
Mockito.verify(iosession2).close();
Mockito.verify(iosession1, Mockito.never()).close();
@@ -760,9 +761,9 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.eq(InetSocketAddress.createUnresolved("somehost", 80)),
- Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.eq(InetSocketAddress.createUnresolved("somehost", 80)),
+ Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 2);
@@ -770,8 +771,8 @@ public class TestNIOConnPool {
final Future<LocalPoolEntry> future1 = pool.lease("somehost", null);
Mockito.verify(ioreactor, Mockito.times(1)).connect(
- Mockito.any(SocketAddress.class), Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.any(SocketAddress.class), Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
pool.requestCompleted(sessionRequest1);
@@ -790,8 +791,8 @@ public class TestNIOConnPool {
Mockito.verify(iosession1).close();
Mockito.verify(ioreactor, Mockito.times(2)).connect(
- Mockito.any(SocketAddress.class), Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class));
+ Matchers.any(SocketAddress.class), Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class));
final PoolStats totals = pool.getTotalStats();
Assert.assertEquals(0, totals.getAvailable());
@@ -819,8 +820,8 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.any(SocketAddress.class), Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class), Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1, sessionRequest2);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 2);
@@ -875,8 +876,8 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.any(SocketAddress.class), Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class), Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1, sessionRequest2);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 2, 2);
@@ -940,8 +941,8 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.any(SocketAddress.class), Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class), Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1);
final LocalSessionPool pool = new LocalSessionPool(ioreactor, 1, 1);
@@ -1037,8 +1038,8 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.any(SocketAddress.class), Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class), Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1);
Mockito.when(ioreactor.getStatus()).thenReturn(IOReactorStatus.ACTIVE);
@@ -1071,8 +1072,8 @@ public class TestNIOConnPool {
final ConnectingIOReactor ioreactor = Mockito.mock(ConnectingIOReactor.class);
Mockito.when(ioreactor.connect(
- Mockito.any(SocketAddress.class), Mockito.any(SocketAddress.class),
- Mockito.any(), Mockito.any(SessionRequestCallback.class))).
+ Matchers.any(SocketAddress.class), Matchers.any(SocketAddress.class),
+ Matchers.any(), Matchers.any(SessionRequestCallback.class))).
thenReturn(sessionRequest1);
Mockito.when(ioreactor.getStatus()).thenReturn(IOReactorStatus.ACTIVE);
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestBasicAsyncRequestHandler.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestBasicAsyncRequestHandler.java b/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestBasicAsyncRequestHandler.java
index 866d989..3b44478 100644
--- a/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestBasicAsyncRequestHandler.java
+++ b/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestBasicAsyncRequestHandler.java
@@ -38,6 +38,7 @@ import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Matchers;
import org.mockito.Mockito;
public class TestBasicAsyncRequestHandler {
@@ -89,7 +90,7 @@ public class TestBasicAsyncRequestHandler {
this.asyncRequestHandler.handle(this.request, this.httpexchange, this.context);
Mockito.verify(this.requestHandler).handle(
- Mockito.eq(this.request), Mockito.eq(this.response), Mockito.eq(this.context));
+ Matchers.eq(this.request), Matchers.eq(this.response), Matchers.eq(this.context));
Mockito.verify(this.httpexchange).submitResponse();
}
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequestExecutor.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequestExecutor.java b/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequestExecutor.java
index 6bc3314..3568fd0 100644
--- a/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequestExecutor.java
+++ b/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequestExecutor.java
@@ -52,6 +52,7 @@ import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Matchers;
import org.mockito.Mockito;
public class TestHttpAsyncRequestExecutor {
@@ -130,7 +131,7 @@ public class TestHttpAsyncRequestExecutor {
this.protocolHandler.closed(this.conn);
- Mockito.verify(this.exchangeHandler).failed(Mockito.any(ConnectionClosedException.class));
+ Mockito.verify(this.exchangeHandler).failed(Matchers.any(ConnectionClosedException.class));
}
@Test
@@ -194,7 +195,7 @@ public class TestHttpAsyncRequestExecutor {
Assert.assertNull(state.getRequest());
Mockito.verify(this.conn, Mockito.times(1)).suspendOutput();
- Mockito.verify(this.conn, Mockito.never()).submitRequest(Mockito.<HttpRequest>any());
+ Mockito.verify(this.conn, Mockito.never()).submitRequest(Matchers.<HttpRequest>any());
}
@Test
@@ -611,7 +612,7 @@ public class TestHttpAsyncRequestExecutor {
Assert.assertFalse(state.isValid());
Mockito.verify(this.conn).close();
- Mockito.verify(this.exchangeHandler).failed(Mockito.any(ConnectionClosedException.class));
+ Mockito.verify(this.exchangeHandler).failed(Matchers.any(ConnectionClosedException.class));
}
@Test
@@ -670,10 +671,10 @@ public class TestHttpAsyncRequestExecutor {
Assert.assertEquals(MessageState.BODY_STREAM, state.getRequestState());
Assert.assertFalse(state.isValid());
- Mockito.verify(this.exchangeHandler).failed(Mockito.any(SocketTimeoutException.class));
+ Mockito.verify(this.exchangeHandler).failed(Matchers.any(SocketTimeoutException.class));
Mockito.verify(this.exchangeHandler).close();
Mockito.verify(this.conn).close();
- Mockito.verify(this.conn, Mockito.never()).setSocketTimeout(Mockito.anyInt());
+ Mockito.verify(this.conn, Mockito.never()).setSocketTimeout(Matchers.anyInt());
}
@Test
@@ -688,7 +689,7 @@ public class TestHttpAsyncRequestExecutor {
Assert.assertEquals(MessageState.BODY_STREAM, state.getRequestState());
Assert.assertFalse(state.isValid());
- Mockito.verify(this.exchangeHandler).failed(Mockito.any(SocketTimeoutException.class));
+ Mockito.verify(this.exchangeHandler).failed(Matchers.any(SocketTimeoutException.class));
Mockito.verify(this.exchangeHandler).close();
Mockito.verify(this.conn).close();
Mockito.verify(this.conn).setSocketTimeout(250);
@@ -706,7 +707,7 @@ public class TestHttpAsyncRequestExecutor {
Assert.assertEquals(MessageState.BODY_STREAM, state.getRequestState());
Assert.assertFalse(state.isValid());
- Mockito.verify(this.exchangeHandler).failed(Mockito.any(SocketTimeoutException.class));
+ Mockito.verify(this.exchangeHandler).failed(Matchers.any(SocketTimeoutException.class));
Mockito.verify(this.exchangeHandler).close();
Mockito.verify(this.conn).shutdown();
}
http://git-wip-us.apache.org/repos/asf/httpcomponents-core/blob/4e99c599/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequester.java
----------------------------------------------------------------------
diff --git a/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequester.java b/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequester.java
index 55a4f06..93b079d 100644
--- a/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequester.java
+++ b/httpcore-nio/src/test/java/org/apache/http/nio/protocol/TestHttpAsyncRequester.java
@@ -47,6 +47,7 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
+import org.mockito.Matchers;
import org.mockito.Mockito;
public class TestHttpAsyncRequester {
@@ -174,8 +175,8 @@ public class TestHttpAsyncRequester {
this.responseConsumer,
this.conn, this.exchangeContext, null);
Assert.assertNotNull(future);
- Mockito.verify(this.requestProducer).failed(Mockito.any(ConnectionClosedException.class));
- Mockito.verify(this.responseConsumer).failed(Mockito.any(ConnectionClosedException.class));
+ Mockito.verify(this.requestProducer).failed(Matchers.any(ConnectionClosedException.class));
+ Mockito.verify(this.responseConsumer).failed(Matchers.any(ConnectionClosedException.class));
Mockito.verify(this.requestProducer, Mockito.atLeastOnce()).close();
Mockito.verify(this.responseConsumer, Mockito.atLeastOnce()).close();
Assert.assertTrue(future.isDone());
@@ -203,7 +204,7 @@ public class TestHttpAsyncRequester {
Assert.assertNotNull(future);
final ArgumentCaptor<FutureCallback> argCaptor = ArgumentCaptor.forClass(FutureCallback.class);
Mockito.verify(this.connPool).lease(
- Mockito.eq(host), Mockito.isNull(), argCaptor.capture());
+ Matchers.eq(host), Matchers.isNull(), argCaptor.capture());
final ConnRequestCallback connRequestCallback = (ConnRequestCallback) argCaptor.getValue();
final Exception oppsie = new Exception();
@@ -227,7 +228,7 @@ public class TestHttpAsyncRequester {
Assert.assertNotNull(future);
final ArgumentCaptor<FutureCallback> argCaptor = ArgumentCaptor.forClass(FutureCallback.class);
Mockito.verify(this.connPool).lease(
- Mockito.eq(host), Mockito.isNull(), argCaptor.capture());
+ Matchers.eq(host), Matchers.isNull(), argCaptor.capture());
final ConnRequestCallback connRequestCallback = (ConnRequestCallback) argCaptor.getValue();
connRequestCallback.cancelled();
@@ -250,7 +251,7 @@ public class TestHttpAsyncRequester {
Assert.assertNotNull(future);
final ArgumentCaptor<FutureCallback> argCaptor = ArgumentCaptor.forClass(FutureCallback.class);
Mockito.verify(this.connPool).lease(
- Mockito.eq(host), Mockito.isNull(), argCaptor.capture());
+ Matchers.eq(host), Matchers.isNull(), argCaptor.capture());
final ConnRequestCallback connRequestCallback = (ConnRequestCallback) argCaptor.getValue();
future.cancel(true);
@@ -275,7 +276,7 @@ public class TestHttpAsyncRequester {
Assert.assertNotNull(future);
final ArgumentCaptor<FutureCallback> argCaptor = ArgumentCaptor.forClass(FutureCallback.class);
Mockito.verify(this.connPool).lease(
- Mockito.eq(host), Mockito.isNull(), argCaptor.capture());
+ Matchers.eq(host), Matchers.isNull(), argCaptor.capture());
final ConnRequestCallback connRequestCallback = (ConnRequestCallback) argCaptor.getValue();
final BasicNIOPoolEntry entry = new BasicNIOPoolEntry("id", host, this.conn);
@@ -308,7 +309,7 @@ public class TestHttpAsyncRequester {
Assert.assertNotNull(future);
final ArgumentCaptor<FutureCallback> argCaptor = ArgumentCaptor.forClass(FutureCallback.class);
Mockito.verify(this.connPool).lease(
- Mockito.eq(host), Mockito.isNull(), argCaptor.capture());
+ Matchers.eq(host), Matchers.isNull(), argCaptor.capture());
final ConnRequestCallback connRequestCallback = (ConnRequestCallback) argCaptor.getValue();
final BasicNIOPoolEntry entry = new BasicNIOPoolEntry("id", host, this.conn);
@@ -341,7 +342,7 @@ public class TestHttpAsyncRequester {
Assert.assertNotNull(future);
final ArgumentCaptor<FutureCallback> argCaptor = ArgumentCaptor.forClass(FutureCallback.class);
Mockito.verify(this.connPool).lease(
- Mockito.eq(host), Mockito.isNull(), argCaptor.capture());
+ Matchers.eq(host), Matchers.isNull(), argCaptor.capture());
final ConnRequestCallback connRequestCallback = (ConnRequestCallback) argCaptor.getValue();
final BasicNIOPoolEntry entry = new BasicNIOPoolEntry("id", host, this.conn);