/*
    * ====================================================================
    * 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.routing;
  
  import java.net.InetAddress;
  import java.util.HashSet;
  import java.util.Set;
  
  import org.apache.http.HttpHost;
  import org.apache.http.conn.routing.RouteInfo.LayerType;
  import org.apache.http.conn.routing.RouteInfo.TunnelType;
  import org.junit.Assert;
  import org.junit.Test;
  
  /**
   * Tests for {@link RouteTracker}.
   */
  @SuppressWarnings("boxing") // test code
  public class TestRouteTracker {
  
      // a selection of constants for generating routes
      public final static
          HttpHost TARGET1 = new HttpHost("target1.test.invalid", 80);
      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", 80);
      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 (final Exception x) {
              throw new ExceptionInInitializerError(x);
          }
      }
  
      @SuppressWarnings("unused")
      @Test
      public void testCstrTargetLocal() {
  
          RouteTracker rt = new RouteTracker(TARGET1, null);
          Assert.assertEquals("wrong target (target,null)",
                       TARGET1, rt.getTargetHost());
          Assert.assertEquals("wrong local address (target,null)",
                       null, rt.getLocalAddress());
          Assert.assertEquals("wrong hop count (target,null)",
                       0, rt.getHopCount());
          Assert.assertEquals("wrong proxy (target,null)",
                       null, rt.getProxyHost());
          Assert.assertEquals("wrong route (target,null)",
                       null, rt.toRoute());
         checkCTLS(rt, false, false, false, false);
 
 
         rt = new RouteTracker(TARGET2, LOCAL61);
         Assert.assertEquals("wrong target (target,local)",
                      TARGET2, rt.getTargetHost());
         Assert.assertEquals("wrong local address (target,local)",
                      LOCAL61, rt.getLocalAddress());
         Assert.assertEquals("wrong hop count (target,local)",
                      0, rt.getHopCount());
         Assert.assertEquals("wrong proxy (target,local)",
                      null, rt.getProxyHost());
         Assert.assertEquals("wrong route (target,local)",
                      null, rt.toRoute());
         checkCTLS(rt, false, false, false, false);
 
 
         rt = null;
         try {
             new RouteTracker(null, LOCAL41);
             Assert.fail("null target not detected");
         } catch (final IllegalArgumentException iax) {
             // expected
         }
     }
 
     @SuppressWarnings("unused")
     @Test
     public void testCstrRoute() {
 
         HttpRoute    r  = new HttpRoute(TARGET1);
         RouteTracker rt = new RouteTracker(r);
         Assert.assertEquals("wrong target (r1)",
                      TARGET1, rt.getTargetHost());
         Assert.assertEquals("wrong local address (r1)",
                      null, rt.getLocalAddress());
         Assert.assertEquals("wrong hop count (r1)",
                      0, rt.getHopCount());
         Assert.assertEquals("wrong proxy (r1)",
                      null, rt.getProxyHost());
         Assert.assertEquals("wrong route (r1)",
                      null, rt.toRoute());
         checkCTLS(rt, false, false, false, false);
 
         r  = new HttpRoute(TARGET2, LOCAL61, true);
         rt = new RouteTracker(r);
         Assert.assertEquals("wrong target (r2)",
                      TARGET2, rt.getTargetHost());
         Assert.assertEquals("wrong local address (r2)",
                      LOCAL61, rt.getLocalAddress());
         Assert.assertEquals("wrong hop count (r2)",
                      0, rt.getHopCount());
         Assert.assertEquals("wrong proxy (r2)",
                      null, rt.getProxyHost());
         Assert.assertEquals("wrong route (r2)",
                      null, rt.toRoute());
         checkCTLS(rt, false, false, false, false);
 
 
         r  = new HttpRoute(TARGET1, LOCAL42, PROXY3, true);
         rt = new RouteTracker(r);
         Assert.assertEquals("wrong target (r3)",
                      TARGET1, rt.getTargetHost());
         Assert.assertEquals("wrong local address (r3)",
                      LOCAL42, rt.getLocalAddress());
         Assert.assertEquals("wrong hop count (r3)",
                      0, rt.getHopCount());
         Assert.assertEquals("wrong proxy (r3)",
                      null, rt.getProxyHost());
         Assert.assertEquals("wrong route (r3)",
                      null, rt.toRoute());
         checkCTLS(rt, false, false, false, false);
 
 
         rt = null;
         try {
             new RouteTracker(null);
             Assert.fail("null route not detected");
         } catch (final NullPointerException npx) {
             // expected
         }
     }
 
     @Test
     public void testIllegalArgs() {
 
         final RouteTracker rt = new RouteTracker(TARGET2, null);
 
         try {
             rt.connectProxy(null, true);
             Assert.fail("missing proxy argument not detected (connect/false)");
         } catch (final IllegalArgumentException iax) {
             // expected
         }
 
         try {
             rt.connectProxy(null, false);
             Assert.fail("missing proxy argument not detected (connect/true)");
         } catch (final IllegalArgumentException iax) {
             // expected
         }
 
         rt.connectProxy(PROXY1, false);
 
         try {
             rt.tunnelProxy(null, false);
             Assert.fail("missing proxy argument not detected (tunnel/false)");
         } catch (final IllegalArgumentException iax) {
             // expected
         }
 
         try {
             rt.tunnelProxy(null, true);
             Assert.fail("missing proxy argument not detected (tunnel/true)");
         } catch (final IllegalArgumentException iax) {
             // expected
         }
 
         try {
             rt.getHopTarget(-1);
             Assert.fail("negative hop index not detected");
         } catch (final IllegalArgumentException iax) {
             // expected
         }
 
         try {
             rt.getHopTarget(2);
             Assert.fail("excessive hop index not detected");
         } catch (final IllegalArgumentException iax) {
             // expected
         }
     }
 
     @Test
     public void testIllegalStates() {
 
         final RouteTracker rt = new RouteTracker(TARGET1, null);
 
         try {
             rt.tunnelTarget(false);
             Assert.fail("unconnectedness not detected (tunnelTarget)");
         } catch (final IllegalStateException isx) {
             // expected
         }
 
         try {
             rt.tunnelProxy(PROXY1, false);
             Assert.fail("unconnectedness not detected (tunnelProxy)");
         } catch (final IllegalStateException isx) {
             // expected
         }
 
         try {
             rt.layerProtocol(true);
             Assert.fail("unconnectedness not detected (layerProtocol)");
         } catch (final IllegalStateException isx) {
             // expected
         }
 
 
         // connect directly
         rt.connectTarget(false);
 
         try {
             rt.connectTarget(false);
             Assert.fail("connectedness not detected (connectTarget)");
         } catch (final IllegalStateException isx) {
             // expected
         }
 
         try {
             rt.connectProxy(PROXY2, false);
             Assert.fail("connectedness not detected (connectProxy)");
         } catch (final IllegalStateException isx) {
             // expected
         }
 
         try {
             rt.tunnelTarget(false);
             Assert.fail("unproxiedness not detected (tunnelTarget)");
         } catch (final IllegalStateException isx) {
             // expected
         }
 
         try {
             rt.tunnelProxy(PROXY1, false);
             Assert.fail("unproxiedness not detected (tunnelProxy)");
         } catch (final IllegalStateException isx) {
             // expected
         }
     }
 
     @Test
     public void testDirectRoutes() {
 
         final HttpRouteDirector rd = new BasicRouteDirector();
         HttpRoute r = new HttpRoute(TARGET1, LOCAL41, false);
         RouteTracker rt = new RouteTracker(r);
         boolean complete = checkVia(rt, r, rd, 2);
         Assert.assertTrue("incomplete route 1", complete);
 
         r = new HttpRoute(TARGET2, LOCAL62, true);
         rt = new RouteTracker(r);
         complete = checkVia(rt, r, rd, 2);
         Assert.assertTrue("incomplete route 2", complete);
     }
 
     @Test
     public void testProxyRoutes() {
 
         final HttpRouteDirector rd = new BasicRouteDirector();
         HttpRoute r = new HttpRoute(TARGET2, null, PROXY1, false);
         RouteTracker rt = new RouteTracker(r);
         boolean complete = checkVia(rt, r, rd, 2);
         Assert.assertTrue("incomplete route 1", complete);
 
         // tunnelled, but neither secure nor layered
         r = new HttpRoute(TARGET1, LOCAL61, PROXY3, false,
                           TunnelType.TUNNELLED, LayerType.PLAIN);
         rt = new RouteTracker(r);
         complete = checkVia(rt, r, rd, 3);
         Assert.assertTrue("incomplete route 2", complete);
 
         // tunnelled, layered, but not secure
         r = new HttpRoute(TARGET1, LOCAL61, PROXY3, false,
                           TunnelType.TUNNELLED, LayerType.LAYERED);
         rt = new RouteTracker(r);
         complete = checkVia(rt, r, rd, 4);
         Assert.assertTrue("incomplete route 3", complete);
 
         // tunnelled, layered, secure
         r = new HttpRoute(TARGET1, LOCAL61, PROXY3, true);
         rt = new RouteTracker(r);
         complete = checkVia(rt, r, rd, 4);
         Assert.assertTrue("incomplete route 4", complete);
     }
 
     @Test
     public void testProxyChainRoutes() {
 
         final HttpRouteDirector rd = new BasicRouteDirector();
         HttpHost[] proxies = { PROXY1, PROXY2 };
         HttpRoute r = new HttpRoute(TARGET2, LOCAL42, proxies, false,
                                     TunnelType.PLAIN, LayerType.PLAIN);
         RouteTracker rt = new RouteTracker(r);
         boolean complete = checkVia(rt, r, rd, 3);
         Assert.assertTrue("incomplete route 1", complete);
 
         // tunnelled, but neither secure nor layered
         proxies = new HttpHost[]{ PROXY3, PROXY2 };
         r = new HttpRoute(TARGET1, null, proxies, false,
                           TunnelType.TUNNELLED, LayerType.PLAIN);
         rt = new RouteTracker(r);
         complete = checkVia(rt, r, rd, 4);
         Assert.assertTrue("incomplete route 2", complete);
 
         // tunnelled, layered, but not secure
         proxies = new HttpHost[]{ PROXY3, PROXY2, PROXY1 };
         r = new HttpRoute(TARGET2, LOCAL61, proxies, false,
                           TunnelType.TUNNELLED, LayerType.LAYERED);
         rt = new RouteTracker(r);
         complete = checkVia(rt, r, rd, 6);
         Assert.assertTrue("incomplete route 3", complete);
 
         // tunnelled, layered, secure
         proxies = new HttpHost[]{ PROXY1, PROXY3 };
         r = new HttpRoute(TARGET1, LOCAL61, proxies, true,
                           TunnelType.TUNNELLED, LayerType.LAYERED);
         rt = new RouteTracker(r);
         complete = checkVia(rt, r, rd, 5);
         Assert.assertTrue("incomplete route 4", complete);
     }
 
     @Test
     public void testEqualsHashcodeCloneToString()
         throws CloneNotSupportedException {
 
         final RouteTracker rt0 = new RouteTracker(TARGET1, null);
         final RouteTracker rt1 = new RouteTracker(TARGET2, null);
         final RouteTracker rt2 = new RouteTracker(TARGET1, null);
         final RouteTracker rt3 = new RouteTracker(TARGET1, null);
         final RouteTracker rt4 = new RouteTracker(TARGET1, LOCAL41);
         final RouteTracker rt6 = new RouteTracker(TARGET1, LOCAL62);
 
         Assert.assertFalse("rt0", rt0.equals(null));
         Assert.assertTrue("rt0", rt0.equals(rt0));
         Assert.assertFalse("rt0", rt0.equals(rt0.toString()));
 
         Assert.assertFalse("rt0 == rt4", rt0.equals(rt4));
         Assert.assertFalse("rt0 == rt1", rt0.equals(rt1)); // Check host takes part in equals
 
         // Check that connection takes part in equals
         Assert.assertTrue("rt0 != rt2", rt0.equals(rt2));
         rt2.connectTarget(false);
         Assert.assertFalse("rt0 == rt2", rt0.equals(rt2));
 
         Assert.assertTrue("rt0 != rt3", rt0.equals(rt3));
         rt3.connectTarget(true);
         Assert.assertFalse("rt0 == rt3", rt0.equals(rt3));
         Assert.assertFalse("rt2 == rt3", rt2.equals(rt3)); // Test secure takes part
 
         // TODO needs tests for tunnel and layered
 
         Assert.assertFalse("rt4 == rt0", rt4.equals(rt0));
         Assert.assertFalse("rt0 == rt6", rt0.equals(rt6));
         Assert.assertFalse("rt6 == rt0", rt6.equals(rt0));
         Assert.assertFalse("rt4 == rt6", rt4.equals(rt6));
         Assert.assertFalse("rt6 == rt4", rt6.equals(rt4));
 
         // it is likely but not guaranteed that the hashcodes are different
         Assert.assertFalse("rt0 == rt4 (hashcode)", rt0.hashCode() == rt4.hashCode());
         Assert.assertFalse("rt0 == rt6 (hashcode)", rt0.hashCode() == rt6.hashCode());
         Assert.assertFalse("rt6 == rt4 (hashcode)", rt6.hashCode() == rt4.hashCode());
 
         Assert.assertEquals("rt0 (clone)", rt0, rt0.clone());
         Assert.assertEquals("rt4 (clone)", rt4, rt4.clone());
         Assert.assertEquals("rt6 (clone)", rt6, rt6.clone());
 
 
         // we collect (clones of) the different tracked routes along the way
         // rt0 -> direct connection
         // rt1 -> via single proxy
         // rt2 -> via proxy chain
         final Set<RouteTracker> hs = new HashSet<RouteTracker>();
 
         // we also collect hashcodes for the different paths
         // since we can't guarantee what influence the HttpHost hashcodes have,
         // we keep separate sets here
         final Set<Integer> hc0 = new HashSet<Integer>();
         final Set<Integer> hc4 = new HashSet<Integer>();
         final Set<Integer> hc6 = new HashSet<Integer>();
 
         RouteTracker rt = null;
 
         Assert.assertTrue(hs.add(rt0));
         Assert.assertTrue(hs.add(rt4));
         Assert.assertTrue(hs.add(rt6));
 
         Assert.assertTrue(hc0.add(Integer.valueOf(rt0.hashCode())));
         Assert.assertTrue(hc4.add(Integer.valueOf(rt4.hashCode())));
         Assert.assertTrue(hc6.add(Integer.valueOf(rt6.hashCode())));
 
         rt = (RouteTracker) rt0.clone();
         rt.connectTarget(false);
         Assert.assertTrue(hs.add(rt));
         Assert.assertTrue(hc0.add(Integer.valueOf(rt.hashCode())));
 
         rt = (RouteTracker) rt0.clone();
         rt.connectTarget(true);
         Assert.assertTrue(hs.add(rt));
         Assert.assertTrue(hc0.add(Integer.valueOf(rt.hashCode())));
 
 
         // proxy (insecure) -> tunnel (insecure) -> layer (secure)
         rt = (RouteTracker) rt4.clone();
         rt.connectProxy(PROXY1, false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assert.assertTrue(hc4.add(Integer.valueOf(rt.hashCode())));
 
         rt.tunnelTarget(false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assert.assertTrue(hc4.add(Integer.valueOf(rt.hashCode())));
 
         rt.layerProtocol(true);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assert.assertTrue(hc4.add(Integer.valueOf(rt.hashCode())));
 
 
         // proxy (secure) -> tunnel (secure) -> layer (insecure)
         rt = (RouteTracker) rt4.clone();
         rt.connectProxy(PROXY1, true);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assert.assertTrue(hc4.add(Integer.valueOf(rt.hashCode())));
 
         rt.tunnelTarget(true);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assert.assertTrue(hc4.add(Integer.valueOf(rt.hashCode())));
 
         rt.layerProtocol(false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assert.assertTrue(hc4.add(Integer.valueOf(rt.hashCode())));
 
 
         // PROXY1/i -> PROXY2/i -> tunnel/i -> layer/s
         rt = (RouteTracker) rt6.clone();
         rt.connectProxy(PROXY1, false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.tunnelProxy(PROXY2, false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.tunnelTarget(false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.layerProtocol(true);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
 
         // PROXY1/s -> PROXY2/s -> tunnel/s -> layer/i
         rt = (RouteTracker) rt6.clone();
         rt.connectProxy(PROXY1, true);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.tunnelProxy(PROXY2, true);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.tunnelTarget(true);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.layerProtocol(false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
 
         // PROXY2/i -> PROXY1/i -> tunnel/i -> layer/s
         rt = (RouteTracker) rt6.clone();
         rt.connectProxy(PROXY2, false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.tunnelProxy(PROXY1, false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // proxy chain sequence does not affect hashcode, so duplicate:
         // Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.tunnelTarget(false);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // proxy chain sequence does not affect hashcode, so duplicate:
         // Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.layerProtocol(true);
         Assert.assertTrue(hs.add((RouteTracker) rt.clone()));
         // proxy chain sequence does not affect hashcode, so duplicate:
         // Assert.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
 
         // check that all toString are OK and different
         final Set<String> rtstrings = new HashSet<String>();
         for (final RouteTracker current: hs) {
             final String rts = checkToString(current);
             Assert.assertTrue("duplicate toString: " + rts, rtstrings.add(rts));
         }
     }
 
 
     /** Helper to check the status of the four flags. */
     public final static void checkCTLS(final RouteTracker rt,
                                        final boolean c, final boolean t,
                                        final boolean l, final boolean s) {
         final String rts = rt.toString();
         Assert.assertEquals("wrong flag connected: " + rts, c, rt.isConnected());
         Assert.assertEquals("wrong flag tunnelled: " + rts, t, rt.isTunnelled());
         Assert.assertEquals("wrong enum tunnelled: " + rts,
                      t ? TunnelType.TUNNELLED : TunnelType.PLAIN,
                      rt.getTunnelType());
         Assert.assertEquals("wrong flag layered: "   + rts, l, rt.isLayered());
         Assert.assertEquals("wrong enum layered: "   + rts,
                      l ? LayerType.LAYERED : LayerType.PLAIN,
                      rt.getLayerType());
         Assert.assertEquals("wrong flag secure: "    + rts, s, rt.isSecure());
     }
 
 
     /**
      * Helper to check tracking of a route.
      * This uses a {@link HttpRouteDirector} to fake establishing the route,
      * checking the intermediate steps.
      *
      * @param rt        the tracker to check with
      * @param r         the route to establish
      * @param rd        the director to check with
      * @param steps     the step count for this invocation
      *
      * @return  {@code true} iff the route is complete
      */
     public final static boolean checkVia(final RouteTracker rt, final HttpRoute r,
                                          final HttpRouteDirector rd, final int steps) {
 
         final String msg = r.toString() + " @ " + rt.toString();
 
         boolean complete = false;
         int n = steps;
         while (!complete && (n > 0)) {
 
             final int action = rd.nextStep(r, rt.toRoute());
             switch (action) {
 
             case HttpRouteDirector.COMPLETE:
                 complete = true;
                 Assert.assertEquals(r, rt.toRoute());
                 break;
 
             case HttpRouteDirector.CONNECT_TARGET: {
                 final boolean sec = r.isSecure();
                 rt.connectTarget(sec);
                 checkCTLS(rt, true, false, false, sec);
                 Assert.assertEquals("wrong hop count "+msg,
                              1, rt.getHopCount());
                 Assert.assertEquals("wrong hop0 "+msg,
                              r.getTargetHost(), rt.getHopTarget(0));
             } break;
 
             case HttpRouteDirector.CONNECT_PROXY: {
                 // we assume an insecure proxy connection
                 final boolean sec = false;
                 rt.connectProxy(r.getProxyHost(), sec);
                 checkCTLS(rt, true, false, false, sec);
                 Assert.assertEquals("wrong hop count "+msg,
                              2, rt.getHopCount());
                 Assert.assertEquals("wrong hop0 "+msg,
                              r.getProxyHost(), rt.getHopTarget(0));
                 Assert.assertEquals("wrong hop1 "+msg,
                              r.getTargetHost(), rt.getHopTarget(1));
             } break;
 
             case HttpRouteDirector.TUNNEL_TARGET: {
                 final int hops = rt.getHopCount();
                 // we assume an insecure tunnel
                 final boolean sec = false;
                 rt.tunnelTarget(sec);
                 checkCTLS(rt, true, true, false, sec);
                 Assert.assertEquals("wrong hop count "+msg,
                              hops, rt.getHopCount());
                 Assert.assertEquals("wrong hop0 "+msg,
                              r.getProxyHost(), rt.getHopTarget(0));
                 Assert.assertEquals("wrong hopN "+msg,
                              r.getTargetHost(), rt.getHopTarget(hops-1));
             } break;
 
             case HttpRouteDirector.TUNNEL_PROXY: {
                 final int hops = rt.getHopCount(); // before tunnelling
                 // we assume an insecure tunnel
                 final boolean  sec = false;
                 final HttpHost pxy = r.getHopTarget(hops-1);
                 rt.tunnelProxy(pxy, sec);
                 // Since we're tunnelling to a proxy and not the target,
                 // the 'tunelling' flag is false: no end-to-end tunnel.
                 checkCTLS(rt, true, false, false, sec);
                 Assert.assertEquals("wrong hop count "+msg,
                              hops+1, rt.getHopCount());
                 Assert.assertEquals("wrong hop0 "+msg,
                              r.getProxyHost(), rt.getHopTarget(0));
                 Assert.assertEquals("wrong hop"+hops+" "+msg,
                              pxy, rt.getHopTarget(hops-1));
                 Assert.assertEquals("wrong hopN "+msg,
                              r.getTargetHost(), rt.getHopTarget(hops));
             } break;
 
             case HttpRouteDirector.LAYER_PROTOCOL: {
                 final int    hops = rt.getHopCount();
                 final boolean tun = rt.isTunnelled();
                 final boolean sec = r.isSecure();
                 rt.layerProtocol(sec);
                 checkCTLS(rt, true, tun, true, sec);
                 Assert.assertEquals("wrong hop count "+msg,
                              hops, rt.getHopCount());
                 Assert.assertEquals("wrong proxy "+msg,
                              r.getProxyHost(), rt.getProxyHost());
                 Assert.assertEquals("wrong target "+msg,
                              r.getTargetHost(), rt.getTargetHost());
             } break;
 
 
             // UNREACHABLE
             default:
                 Assert.fail("unexpected action " + action + " from director, "+msg);
                 break;
 
             } // switch
             n--;
         }
 
         return complete;
     } // checkVia
 
 
     /**
      * Checks the output of {@code toString}.
      *
      * @param rt        the tracker for which to check the output
      *
      * @return  the result of {@code rt.toString()}
      */
     public final static String checkToString(final RouteTracker rt) {
         if (rt == null) {
             return null;
         }
 
         final String rts = rt.toString();
 
         if (rt.getLocalAddress() != null) {
             final String las = rt.getLocalAddress().toString();
             Assert.assertFalse("no local address in toString(): " + rts,
                     !rts.contains(las));
         }
 
         for (int i=0; i<rt.getHopCount(); i++) {
             final String hts = rt.getHopTarget(i).toString();
             Assert.assertFalse("hop "+i+" ("+hts+") missing in toString(): " + rts,
                     !rts.contains(hts));
         }
 
         return rts;
     }
 
 }