hc-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rola...@apache.org
Subject svn commit: r550077 - in /jakarta/httpcomponents/httpclient/trunk/module-client/src: main/java/org/apache/http/conn/RouteDirector.java test/java/org/apache/http/conn/TestAllConn.java test/java/org/apache/http/conn/TestRouteDirector.java
Date Sat, 23 Jun 2007 18:25:34 GMT
Author: rolandw
Date: Sat Jun 23 11:25:33 2007
New Revision: 550077

URL: http://svn.apache.org/viewvc?view=rev&rev=550077
Log:
tests for RouteDirector at 100% coverage, fixed two bugs

Added:
    jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestRouteDirector.java
  (with props)
Modified:
    jakarta/httpcomponents/httpclient/trunk/module-client/src/main/java/org/apache/http/conn/RouteDirector.java
    jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestAllConn.java

Modified: jakarta/httpcomponents/httpclient/trunk/module-client/src/main/java/org/apache/http/conn/RouteDirector.java
URL: http://svn.apache.org/viewvc/jakarta/httpcomponents/httpclient/trunk/module-client/src/main/java/org/apache/http/conn/RouteDirector.java?view=diff&rev=550077&r1=550076&r2=550077
==============================================================================
--- jakarta/httpcomponents/httpclient/trunk/module-client/src/main/java/org/apache/http/conn/RouteDirector.java
(original)
+++ jakarta/httpcomponents/httpclient/trunk/module-client/src/main/java/org/apache/http/conn/RouteDirector.java
Sat Jun 23 11:25:33 2007
@@ -139,9 +139,14 @@
         // consider it here until there is a real-life use case for it.
 
         // Should we tolerate if security is better than planned?
+        // (plan.isSecure() && !fact.isSecure())
+        if (plan.isSecure() != fact.isSecure())
+            return UNREACHABLE;
 
-        // yes, this would cover the two checks above as well...
-        if (!plan.equals(fact))
+        // Local address has to match only if the plan specifies one.
+        if ((plan.getLocalAddress() != null) &&
+            !plan.getLocalAddress().equals(fact.getLocalAddress())
+            )
             return UNREACHABLE;
 
         return COMPLETE;
@@ -168,7 +173,7 @@
         if (phc < fhc)
             return UNREACHABLE;
 
-        for (int i=0; i<phc-1; i++) {
+        for (int i=0; i<fhc-1; i++) {
             if (!plan.getHopTarget(i).equals(fact.getHopTarget(i)))
                 return UNREACHABLE;
         }
@@ -188,6 +193,7 @@
 
         // tunnel and layering are the same, remains to check the security
         // Should we tolerate if security is better than planned?
+        // (plan.isSecure() && !fact.isSecure())
         if (plan.isSecure() != fact.isSecure())
             return UNREACHABLE;
 

Modified: jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestAllConn.java
URL: http://svn.apache.org/viewvc/jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestAllConn.java?view=diff&rev=550077&r1=550076&r2=550077
==============================================================================
--- jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestAllConn.java
(original)
+++ jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestAllConn.java
Sat Jun 23 11:25:33 2007
@@ -44,6 +44,7 @@
         TestSuite suite = new TestSuite();
 
         suite.addTest(TestHttpRoute.suite());
+        suite.addTest(TestRouteDirector.suite());
         suite.addTest(TestScheme.suite());
 
         return suite;

Added: jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestRouteDirector.java
URL: http://svn.apache.org/viewvc/jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestRouteDirector.java?view=auto&rev=550077
==============================================================================
--- jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestRouteDirector.java
(added)
+++ jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestRouteDirector.java
Sat Jun 23 11:25:33 2007
@@ -0,0 +1,500 @@
+/*
+ * $HeadURL$
+ * $Revision$
+ * $Date$
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+
+package org.apache.http.conn;
+
+
+import java.net.InetAddress;
+import java.util.HashSet;
+import java.util.Iterator;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import org.apache.http.HttpHost;
+
+
+/**
+ * Tests for <code>RouteDirector</code>.
+ */
+public class TestRouteDirector extends TestCase {
+
+    // a selection of constants for generating routes
+    public final static
+        HttpHost TARGET1 = new HttpHost("target1.test.invalid");
+    public final static
+        HttpHost TARGET2 = new HttpHost("target2.test.invalid", 8080);
+    // It is not necessary to have extra targets for https.
+    // The 'layered' and 'secure' flags are specified explicitly
+    // for routes, they will not be determined from the scheme.
+
+    public final static
+        HttpHost PROXY1 = new HttpHost("proxy1.test.invalid");
+    public final static
+        HttpHost PROXY2 = new HttpHost("proxy2.test.invalid", 1080);
+    public final static
+        HttpHost PROXY3 = new HttpHost("proxy3.test.invalid", 88);
+
+    public final static InetAddress LOCAL41;
+    public final static InetAddress LOCAL42;
+    public final static InetAddress LOCAL61;
+    public final static InetAddress LOCAL62;
+
+    // need static initializer to deal with exceptions
+    static {
+        try {
+            LOCAL41 = InetAddress.getByAddress(new byte[]{ 127, 0, 0, 1 });
+            LOCAL42 = InetAddress.getByAddress(new byte[]{ 127, 0, 0, 2 });
+
+            LOCAL61 = InetAddress.getByAddress(new byte[]{
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
+            });
+            LOCAL62 = InetAddress.getByAddress(new byte[]{
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2
+            });
+
+        } catch (Exception x) {
+            throw new ExceptionInInitializerError(x);
+        }
+    }
+
+
+    public TestRouteDirector(String testName) {
+        super(testName);
+    }
+
+    public static void main(String args[]) {
+        String[] testCaseName = { TestRouteDirector.class.getName() };
+        junit.textui.TestRunner.main(testCaseName);
+    }
+
+    public static Test suite() {
+        return new TestSuite(TestRouteDirector.class);
+    }
+
+
+    public void testIllegal() {
+
+        RouteDirector rowdy = new RouteDirector();
+        HttpRoute route = new HttpRoute(TARGET1);
+
+        try {
+            rowdy.nextStep(null, route);
+            fail("null argument not detected");
+        } catch (IllegalArgumentException iax) {
+            // expected
+        }
+    }
+
+
+    public void testDirect() {
+
+        RouteDirector rowdy = new RouteDirector();
+        HttpRoute route1   = new HttpRoute(TARGET1);
+        HttpRoute route2   = new HttpRoute(TARGET2);
+        HttpRoute route1p1 = new HttpRoute(TARGET1, null, PROXY1, false);
+
+        int step = rowdy.nextStep(route1, null);
+        assertEquals("wrong step to route1",
+                     RouteDirector.CONNECT_TARGET, step);
+
+        step = rowdy.nextStep(route2, null);
+        assertEquals("wrong step to route2",
+                     RouteDirector.CONNECT_TARGET, step);
+
+        step = rowdy.nextStep(route1, route1);
+        assertEquals("complete route1 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route2, route2);
+        assertEquals("complete route2 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1, route2);
+        assertEquals("unreachable target not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1, route1p1);
+        assertEquals("invalid proxy not detected",
+                     RouteDirector.UNREACHABLE, step);
+    }
+
+
+    public void testProxy() {
+
+        RouteDirector rowdy = new RouteDirector();
+        HttpRoute route1p1 = new HttpRoute(TARGET1, null, PROXY1, false);
+        HttpRoute route1p2 = new HttpRoute(TARGET1, null, PROXY2, false);
+        HttpRoute route2p1 = new HttpRoute(TARGET2, null, PROXY1, false);
+        HttpRoute route0   = new HttpRoute(PROXY1);
+        HttpRoute route1   = new HttpRoute(TARGET1);
+
+        int step = rowdy.nextStep(route1p1, null);
+        assertEquals("wrong step to route1p1",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1p2, null);
+        assertEquals("wrong step to route1p2",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1p1, route1p1);
+        assertEquals("complete route1p1 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1p2, route1p2);
+        assertEquals("complete route1p2 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route2p1, route2p1);
+        assertEquals("complete route2p1 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1p1, route1p2);
+        assertEquals("unreachable route1p1 via route1p2 not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1p1, route2p1);
+        assertEquals("unreachable route1p1 via route2p1 not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1p1, route0);
+        assertEquals("unreachable route1p1 via route0 not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1p1, route1);
+        assertEquals("unreachable route1p1 via route1 not detected",
+                     RouteDirector.UNREACHABLE, step);
+    }
+
+
+    public void testProxyChain() {
+        HttpHost[] chainA = { PROXY1 };
+        HttpHost[] chainB = { PROXY1, PROXY2 };
+        HttpHost[] chainC = { PROXY2, PROXY1 };
+        HttpHost[] chainD = { PROXY2 };
+
+        RouteDirector rowdy = new RouteDirector();
+        HttpRoute route1cA  = new HttpRoute(TARGET1, null, chainA,
+                                            false, false, false);
+        HttpRoute route1cB  = new HttpRoute(TARGET1, null, chainB,
+                                            false, false, false);
+        HttpRoute route1cC  = new HttpRoute(TARGET1, null, chainC,
+                                            false, false, false);
+        HttpRoute route1cD  = new HttpRoute(TARGET1, null, chainC,
+                                            false, false, false);
+        HttpRoute route1c0  = new HttpRoute(TARGET1, null, false);
+
+        int step = rowdy.nextStep(route1cA, null);
+        assertEquals("wrong step to route1cA",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1cB, null);
+        assertEquals("wrong step to route1cB",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1cC, null);
+        assertEquals("wrong step to route1cC",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1cD, null);
+        assertEquals("wrong step to route1cD",
+                     RouteDirector.CONNECT_PROXY, step);
+
+
+        step = rowdy.nextStep(route1cB, route1cA);
+        assertEquals("wrong step to route 1cB from 1cA",
+                     RouteDirector.TUNNEL_PROXY, step);
+
+        step = rowdy.nextStep(route1cB, route1cB);
+        assertEquals("complete route 1cB not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1cB, route1cC);
+        assertEquals("unreachable route 1cB from 1cC not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1cB, route1cD);
+        assertEquals("unreachable route 1cB from 1cD not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+
+        step = rowdy.nextStep(route1cA, route1cB);
+        assertEquals("unreachable route 1cA from 1cB not detected",
+                     RouteDirector.UNREACHABLE, step);
+    }
+
+
+    public void testLocalDirect() {
+
+        RouteDirector rowdy = new RouteDirector();
+        HttpRoute route1l41 = new HttpRoute(TARGET1, LOCAL41, false);
+        HttpRoute route1l42 = new HttpRoute(TARGET1, LOCAL42, false);
+        HttpRoute route1l61 = new HttpRoute(TARGET1, LOCAL61, false);
+        HttpRoute route1l00 = new HttpRoute(TARGET1, null, false);
+
+        int step = rowdy.nextStep(route1l41, null);
+        assertEquals("wrong step to route1l41",
+                     RouteDirector.CONNECT_TARGET, step);
+
+        step = rowdy.nextStep(route1l42, null);
+        assertEquals("wrong step to route1l42",
+                     RouteDirector.CONNECT_TARGET, step);
+
+        step = rowdy.nextStep(route1l61, null);
+        assertEquals("wrong step to route1l61",
+                     RouteDirector.CONNECT_TARGET, step);
+
+        step = rowdy.nextStep(route1l00, null);
+        assertEquals("wrong step to route1l00",
+                     RouteDirector.CONNECT_TARGET, step);
+
+        step = rowdy.nextStep(route1l41, route1l41);
+        assertEquals("complete route1l41 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1l42, route1l42);
+        assertEquals("complete route1l42 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1l61, route1l61);
+        assertEquals("complete route1l61 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1l00, route1l00);
+        assertEquals("complete route1l00 not detected",
+                     RouteDirector.COMPLETE, step);
+
+
+        step = rowdy.nextStep(route1l41, route1l42);
+        assertEquals("unreachable route1l41 via route1l42 not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1l41, route1l61);
+        assertEquals("unreachable route1l41 via route1l61 not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1l41, route1l00);
+        assertEquals("unreachable route1l41 via route1l00 not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+
+        step = rowdy.nextStep(route1l00, route1l41);
+        assertEquals("complete route1l00 as route1l41 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1l00, route1l42);
+        assertEquals("complete route1l00 as route1l42 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1l00, route1l61);
+        assertEquals("complete route1l00 as route1l61 not detected",
+                     RouteDirector.COMPLETE, step);
+    }
+
+
+    public void testDirectSecure() {
+
+        RouteDirector rowdy = new RouteDirector();
+        HttpRoute route1u   = new HttpRoute(TARGET1, null, false);
+        HttpRoute route1s   = new HttpRoute(TARGET1, null, true);
+        HttpRoute route1p1u = new HttpRoute(TARGET1, null, PROXY1, false);
+        HttpRoute route1p1s = new HttpRoute(TARGET1, null, PROXY1, true);
+
+        int step = rowdy.nextStep(route1u, null);
+        assertEquals("wrong step to route1u",
+                     RouteDirector.CONNECT_TARGET, step);
+
+        step = rowdy.nextStep(route1s, null);
+        assertEquals("wrong step to route1s",
+                     RouteDirector.CONNECT_TARGET, step);
+
+        // unrequested security is currently not tolerated
+        step = rowdy.nextStep(route1u, route1s);
+        assertEquals("unreachable route 1u from 1s not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        // secure layering of direct connections is currently not supported
+        step = rowdy.nextStep(route1s, route1u);
+        assertEquals("unreachable route 1s from 1u not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+
+
+        step = rowdy.nextStep(route1s, route1p1u);
+        assertEquals("unreachable route 1s from 1p1u not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1s, route1p1s);
+        assertEquals("unreachable route 1s from 1p1s not detected",
+                     RouteDirector.UNREACHABLE, step);
+    }
+
+
+    public void testProxyTLS() {
+
+        RouteDirector rowdy = new RouteDirector();
+        HttpRoute route1    = new HttpRoute(TARGET1, null, PROXY1,
+                                            false, false, false);
+        HttpRoute route1t   = new HttpRoute(TARGET1, null, PROXY1,
+                                            false, true, false);
+        HttpRoute route1tl  = new HttpRoute(TARGET1, null, PROXY1,
+                                            false, true, true);
+        HttpRoute route1s   = new HttpRoute(TARGET1, null, PROXY1,
+                                            true, false, false);
+        HttpRoute route1ts  = new HttpRoute(TARGET1, null, PROXY1,
+                                            true, true, false);
+        HttpRoute route1tls = new HttpRoute(TARGET1, null, PROXY1,
+                                            true, true, true);
+
+        // we don't consider a route that is layered but not tunnelled
+
+        int step = rowdy.nextStep(route1, null);
+        assertEquals("wrong step to route1",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1t, null);
+        assertEquals("wrong step to route1t",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1tl, null);
+        assertEquals("wrong step to route1tl",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1s, null);
+        assertEquals("wrong step to route1s",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1ts, null);
+        assertEquals("wrong step to route1ts",
+                     RouteDirector.CONNECT_PROXY, step);
+
+        step = rowdy.nextStep(route1tls, null);
+        assertEquals("wrong step to route1tls",
+                     RouteDirector.CONNECT_PROXY, step);
+
+
+        step = rowdy.nextStep(route1, route1);
+        assertEquals("complete route1 not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1t, route1t);
+        assertEquals("complete route1t not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1tl, route1tl);
+        assertEquals("complete route1tl not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1s, route1s);
+        assertEquals("complete route1s not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1ts, route1ts);
+        assertEquals("complete route1ts not detected",
+                     RouteDirector.COMPLETE, step);
+
+        step = rowdy.nextStep(route1tls, route1tls);
+        assertEquals("complete route1tls not detected",
+                     RouteDirector.COMPLETE, step);
+
+
+
+        step = rowdy.nextStep(route1, route1t);
+        assertEquals("unreachable route1 from 1t not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1, route1tl);
+        assertEquals("unreachable route1 from 1tl not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        // unrequested security is currently not tolerated
+        step = rowdy.nextStep(route1, route1s);
+        assertEquals("unreachable route1 from 1s not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1, route1ts);
+        assertEquals("unreachable route1 from 1ts not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        step = rowdy.nextStep(route1, route1tls);
+        assertEquals("unreachable route1 from 1tls not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+
+        // securing requires layering
+        step = rowdy.nextStep(route1s, route1);
+        assertEquals("unreachable route1s from 1 not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+        // securing requires layering, and multiple layers are not supported
+        step = rowdy.nextStep(route1tls, route1tl);
+        assertEquals("unreachable route1tls from 1tl not detected",
+                     RouteDirector.UNREACHABLE, step);
+
+
+        // cases where tunnelling to the target is required
+        step = rowdy.nextStep(route1t, route1);
+        assertEquals("wrong step to route1t from 1",
+                     RouteDirector.TUNNEL_TARGET, step);
+
+        step = rowdy.nextStep(route1tl, route1);
+        assertEquals("wrong step to route1tl from 1",
+                     RouteDirector.TUNNEL_TARGET, step);
+
+        step = rowdy.nextStep(route1tls, route1);
+        assertEquals("wrong step to route1tls from 1",
+                     RouteDirector.TUNNEL_TARGET, step);
+
+
+        // cases where layering on the tunnel is required
+        step = rowdy.nextStep(route1tl, route1t);
+        assertEquals("wrong step to route1tl from 1t",
+                     RouteDirector.LAYER_PROTOCOL, step);
+
+        step = rowdy.nextStep(route1tl, route1ts);
+        assertEquals("wrong step to route1tl from 1ts",
+                     RouteDirector.LAYER_PROTOCOL, step);
+
+        step = rowdy.nextStep(route1tls, route1t);
+        assertEquals("wrong step to route1tls from 1t",
+                     RouteDirector.LAYER_PROTOCOL, step);
+
+        step = rowdy.nextStep(route1tls, route1ts);
+        assertEquals("wrong step to route1tls from 1ts",
+                     RouteDirector.LAYER_PROTOCOL, step);
+
+        // There are some odd cases left over, like having a secure tunnel
+        // that becomes unsecure by layering, or a secure connection to a
+        // proxy that becomes unsecure by tunnelling to another proxy.
+    }
+
+
+} // class TestRouteDirector

Propchange: jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestRouteDirector.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestRouteDirector.java
------------------------------------------------------------------------------
    svn:keywords = Date Author Id Revision HeadURL

Propchange: jakarta/httpcomponents/httpclient/trunk/module-client/src/test/java/org/apache/http/conn/TestRouteDirector.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain



Mime
View raw message