/*
    * ====================================================================
    * 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.hc.client5.http.impl.routing;
  
  import java.net.InetAddress;
  import java.util.HashSet;
  import java.util.Set;
  
  import org.apache.hc.client5.http.HttpRoute;
  import org.apache.hc.client5.http.RouteInfo.LayerType;
  import org.apache.hc.client5.http.RouteInfo.TunnelType;
  import org.apache.hc.client5.http.RouteTracker;
  import org.apache.hc.client5.http.routing.HttpRouteDirector;
  import org.apache.hc.core5.http.HttpHost;
  import org.junit.jupiter.api.Assertions;
  import org.junit.jupiter.api.Test;
  
  /**
   * Tests for {@link RouteTracker}.
   */
  @SuppressWarnings("boxing") // test code
  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
      void testCstrTargetLocal() {
  
          RouteTracker rt = new RouteTracker(TARGET1, null);
          Assertions.assertEquals(TARGET1, rt.getTargetHost(), "wrong target (target,null)");
          Assertions.assertNull(rt.getLocalAddress(), "wrong local address (target,null)");
          Assertions.assertEquals(0, rt.getHopCount(), "wrong hop count (target,null)");
          Assertions.assertNull(rt.getProxyHost(), "wrong proxy (target,null)");
          Assertions.assertNull(rt.toRoute(), "wrong route (target,null)");
          checkCTLS(rt, false, false, false, false);
  
  
          rt = new RouteTracker(TARGET2, LOCAL61);
          Assertions.assertEquals(TARGET2, rt.getTargetHost(), "wrong target (target,local)");
          Assertions.assertEquals(LOCAL61, rt.getLocalAddress(), "wrong local address (target,local)");
          Assertions.assertEquals(0, rt.getHopCount(), "wrong hop count (target,local)");
         Assertions.assertNull(rt.getProxyHost(), "wrong proxy (target,local)");
         Assertions.assertNull(rt.toRoute(), "wrong route (target,local)");
         checkCTLS(rt, false, false, false, false);
 
         Assertions.assertThrows(NullPointerException.class, () -> new RouteTracker(null, LOCAL41));
     }
 
     @SuppressWarnings("unused")
     @Test
     void testCstrRoute() {
 
         HttpRoute r = new HttpRoute(TARGET1);
         RouteTracker rt = new RouteTracker(r);
         Assertions.assertEquals(TARGET1, rt.getTargetHost(), "wrong target (r1)");
         Assertions.assertNull(rt.getLocalAddress(), "wrong local address (r1)");
         Assertions.assertEquals(0, rt.getHopCount(), "wrong hop count (r1)");
         Assertions.assertNull(rt.getProxyHost(), "wrong proxy (r1)");
         Assertions.assertNull(rt.toRoute(), "wrong route (r1)");
         checkCTLS(rt, false, false, false, false);
 
         r = new HttpRoute(TARGET2, LOCAL61, true);
         rt = new RouteTracker(r);
         Assertions.assertEquals(TARGET2, rt.getTargetHost(), "wrong target (r2)");
         Assertions.assertEquals(LOCAL61, rt.getLocalAddress(), "wrong local address (r2)");
         Assertions.assertEquals(0, rt.getHopCount(), "wrong hop count (r2)");
         Assertions.assertNull(rt.getProxyHost(), "wrong proxy (r2)");
         Assertions.assertNull(rt.toRoute(), "wrong route (r2)");
         checkCTLS(rt, false, false, false, false);
 
 
         r = new HttpRoute(TARGET1, LOCAL42, PROXY3, true);
         rt = new RouteTracker(r);
         Assertions.assertEquals(TARGET1, rt.getTargetHost(), "wrong target (r3)");
         Assertions.assertEquals(LOCAL42, rt.getLocalAddress(), "wrong local address (r3)");
         Assertions.assertEquals(0, rt.getHopCount(), "wrong hop count (r3)");
         Assertions.assertNull(rt.getProxyHost(), "wrong proxy (r3)");
         Assertions.assertNull(rt.toRoute(), "wrong route (r3)");
         checkCTLS(rt, false, false, false, false);
 
         Assertions.assertThrows(NullPointerException.class, () -> new RouteTracker(null));
     }
 
     @Test
     void testIllegalArgs() {
 
         final RouteTracker rt = new RouteTracker(TARGET2, null);
 
         Assertions.assertThrows(NullPointerException.class, () -> rt.connectProxy(null, true));
         Assertions.assertThrows(NullPointerException.class, () -> rt.connectProxy(null, false));
 
         rt.connectProxy(PROXY1, false);
 
         Assertions.assertThrows(NullPointerException.class, () -> rt.tunnelProxy(null, false));
         Assertions.assertThrows(NullPointerException.class, () -> rt.tunnelProxy(null, true));
         Assertions.assertThrows(IllegalArgumentException.class, () -> rt.getHopTarget(-1));
         Assertions.assertThrows(IllegalArgumentException.class, () -> rt.getHopTarget(2));
     }
 
     @Test
     void testIllegalStates() {
 
         final RouteTracker rt = new RouteTracker(TARGET1, null);
 
         Assertions.assertThrows(IllegalStateException.class, () -> rt.tunnelTarget(false));
         Assertions.assertThrows(IllegalStateException.class, () -> rt.tunnelProxy(PROXY1, false));
         Assertions.assertThrows(IllegalStateException.class, () -> rt.layerProtocol(true));
 
         // connect directly
         rt.connectTarget(false);
 
         Assertions.assertThrows(IllegalStateException.class, () -> rt.connectTarget(false));
         Assertions.assertThrows(IllegalStateException.class, () -> rt.connectProxy(PROXY2, false));
         Assertions.assertThrows(IllegalStateException.class, () -> rt.tunnelTarget(false));
         Assertions.assertThrows(IllegalStateException.class, () -> rt.tunnelProxy(PROXY1, false));
     }
 
     @Test
     void testDirectRoutes() {
 
         final HttpRouteDirector rd = BasicRouteDirector.INSTANCE;
         HttpRoute r = new HttpRoute(TARGET1, LOCAL41, false);
         RouteTracker rt = new RouteTracker(r);
         boolean complete = checkVia(rt, r, rd, 2);
         Assertions.assertTrue(complete, "incomplete route 1");
 
         r = new HttpRoute(TARGET2, LOCAL62, true);
         rt = new RouteTracker(r);
         complete = checkVia(rt, r, rd, 2);
         Assertions.assertTrue(complete, "incomplete route 2");
     }
 
     @Test
     void testProxyRoutes() {
 
         final HttpRouteDirector rd = BasicRouteDirector.INSTANCE;
         HttpRoute r = new HttpRoute(TARGET2, null, PROXY1, false);
         RouteTracker rt = new RouteTracker(r);
         boolean complete = checkVia(rt, r, rd, 2);
         Assertions.assertTrue(complete, "incomplete route 1");
 
         // 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);
         Assertions.assertTrue(complete, "incomplete route 2");
 
         // 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);
         Assertions.assertTrue(complete, "incomplete route 3");
 
         // tunnelled, layered, secure
         r = new HttpRoute(TARGET1, LOCAL61, PROXY3, true);
         rt = new RouteTracker(r);
         complete = checkVia(rt, r, rd, 4);
         Assertions.assertTrue(complete, "incomplete route 4");
     }
 
     @Test
     void testProxyChainRoutes() {
 
         final HttpRouteDirector rd = BasicRouteDirector.INSTANCE;
         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);
         Assertions.assertTrue(complete, "incomplete route 1");
 
         // 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);
         Assertions.assertTrue(complete, "incomplete route 2");
 
         // 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);
         Assertions.assertTrue(complete, "incomplete route 3");
 
         // 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);
         Assertions.assertTrue(complete, "incomplete route 4");
     }
 
     @Test
     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);
 
         Assertions.assertNotEquals(null, rt0, "rt0");
         Assertions.assertEquals(rt0, rt0, "rt0");
         Assertions.assertNotEquals("rt0", rt0, rt0.toString());
 
         Assertions.assertNotEquals(rt0, rt4, "rt0 == rt4");
         Assertions.assertNotEquals(rt0, rt1, "rt0 == rt1"); // Check host takes part in equals
 
         // Check that connection takes part in equals
         Assertions.assertEquals(rt0, rt2, "rt0 != rt2");
         rt2.connectTarget(false);
         Assertions.assertNotEquals(rt0, rt2, "rt0 == rt2");
 
         Assertions.assertEquals(rt0, rt3, "rt0 != rt3");
         rt3.connectTarget(true);
         Assertions.assertNotEquals(rt0, rt3, "rt0 == rt3");
         Assertions.assertNotEquals(rt2, rt3, "rt2 == rt3"); // Test secure takes part
 
         // TODO needs tests for tunnel and layered
 
         Assertions.assertNotEquals(rt4, rt0, "rt4 == rt0");
         Assertions.assertNotEquals(rt0, rt6, "rt0 == rt6");
         Assertions.assertNotEquals(rt6, rt0, "rt6 == rt0");
         Assertions.assertNotEquals(rt4, rt6, "rt4 == rt6");
         Assertions.assertNotEquals(rt6, rt4, "rt6 == rt4");
 
         // it is likely but not guaranteed that the hashcodes are different
         Assertions.assertNotEquals(rt0.hashCode(), rt4.hashCode(), "rt0 == rt4 (hashcode)");
         Assertions.assertNotEquals(rt0.hashCode(), rt6.hashCode(), "rt0 == rt6 (hashcode)");
         Assertions.assertNotEquals(rt6.hashCode(), rt4.hashCode(), "rt6 == rt4 (hashcode)");
 
         Assertions.assertEquals(rt0, rt0.clone(), "rt0 (clone)");
         Assertions.assertEquals(rt4, rt4.clone(), "rt4 (clone)");
         Assertions.assertEquals(rt6, rt6.clone(), "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<>();
 
         // 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<>();
         final Set<Integer> hc4 = new HashSet<>();
         final Set<Integer> hc6 = new HashSet<>();
 
         RouteTracker rt = null;
 
         Assertions.assertTrue(hs.add(rt0));
         Assertions.assertTrue(hs.add(rt4));
         Assertions.assertTrue(hs.add(rt6));
 
         Assertions.assertTrue(hc0.add(rt0.hashCode()));
         Assertions.assertTrue(hc4.add(rt4.hashCode()));
         Assertions.assertTrue(hc6.add(rt6.hashCode()));
 
         rt = (RouteTracker) rt0.clone();
         rt.connectTarget(false);
         Assertions.assertTrue(hs.add(rt));
         Assertions.assertTrue(hc0.add(rt.hashCode()));
 
         rt = (RouteTracker) rt0.clone();
         rt.connectTarget(true);
         Assertions.assertTrue(hs.add(rt));
         Assertions.assertTrue(hc0.add(rt.hashCode()));
 
 
         // proxy (insecure) -> tunnel (insecure) -> layer (secure)
         rt = (RouteTracker) rt4.clone();
         rt.connectProxy(PROXY1, false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assertions.assertTrue(hc4.add(rt.hashCode()));
 
         rt.tunnelTarget(false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assertions.assertTrue(hc4.add(rt.hashCode()));
 
         rt.layerProtocol(true);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assertions.assertTrue(hc4.add(rt.hashCode()));
 
 
         // proxy (secure) -> tunnel (secure) -> layer (insecure)
         rt = (RouteTracker) rt4.clone();
         rt.connectProxy(PROXY1, true);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assertions.assertTrue(hc4.add(rt.hashCode()));
 
         rt.tunnelTarget(true);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assertions.assertTrue(hc4.add(rt.hashCode()));
 
         rt.layerProtocol(false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assertions.assertTrue(hc4.add(rt.hashCode()));
 
 
         // PROXY1/i -> PROXY2/i -> tunnel/i -> layer/s
         rt = (RouteTracker) rt6.clone();
         rt.connectProxy(PROXY1, false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assertions.assertTrue(hc6.add(rt.hashCode()));
 
         rt.tunnelProxy(PROXY2, false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assertions.assertTrue(hc6.add(rt.hashCode()));
 
         rt.tunnelTarget(false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assertions.assertTrue(hc6.add(rt.hashCode()));
 
         rt.layerProtocol(true);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assertions.assertTrue(hc6.add(rt.hashCode()));
 
 
         // PROXY1/s -> PROXY2/s -> tunnel/s -> layer/i
         rt = (RouteTracker) rt6.clone();
         rt.connectProxy(PROXY1, true);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assertions.assertTrue(hc6.add(rt.hashCode()));
 
         rt.tunnelProxy(PROXY2, true);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assertions.assertTrue(hc6.add(rt.hashCode()));
 
         rt.tunnelTarget(true);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assertions.assertTrue(hc6.add(rt.hashCode()));
 
         rt.layerProtocol(false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         Assertions.assertTrue(hc6.add(rt.hashCode()));
 
 
         // PROXY2/i -> PROXY1/i -> tunnel/i -> layer/s
         rt = (RouteTracker) rt6.clone();
         rt.connectProxy(PROXY2, false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // this is not guaranteed to be unique...
         Assertions.assertTrue(hc6.add(rt.hashCode()));
 
         rt.tunnelProxy(PROXY1, false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // proxy chain sequence does not affect hashcode, so duplicate:
         // Assertions.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.tunnelTarget(false);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // proxy chain sequence does not affect hashcode, so duplicate:
         // Assertions.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
         rt.layerProtocol(true);
         Assertions.assertTrue(hs.add((RouteTracker) rt.clone()));
         // proxy chain sequence does not affect hashcode, so duplicate:
         // Assertions.assertTrue(hc6.add(Integer.valueOf(rt.hashCode())));
 
 
         // check that all toString are OK and different
         final Set<String> rtstrings = new HashSet<>();
         for (final RouteTracker current : hs) {
             final String rts = checkToString(current);
             Assertions.assertTrue(rtstrings.add(rts), "duplicate toString: " + 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();
         Assertions.assertEquals(c, rt.isConnected(), "wrong flag connected: " + rts);
         Assertions.assertEquals(t, rt.isTunnelled(), "wrong flag tunnelled: " + rts);
         Assertions.assertEquals(t ? TunnelType.TUNNELLED : TunnelType.PLAIN,
                 rt.getTunnelType(), "wrong enum tunnelled: " + rts);
         Assertions.assertEquals(l, rt.isLayered(), "wrong flag layered: " + rts);
         Assertions.assertEquals(l ? LayerType.LAYERED : LayerType.PLAIN,
                 rt.getLayerType(), "wrong enum layered: " + rts);
         Assertions.assertEquals(s, rt.isSecure(), "wrong flag secure: " + rts);
     }
 
 
     /**
      * 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 + " @ " + rt;
 
         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;
                     Assertions.assertEquals(r, rt.toRoute());
                     break;
 
                 case HttpRouteDirector.CONNECT_TARGET: {
                     final boolean sec = r.isSecure();
                     rt.connectTarget(sec);
                     checkCTLS(rt, true, false, false, sec);
                     Assertions.assertEquals(1, rt.getHopCount(), "wrong hop count " + msg);
                     Assertions.assertEquals(r.getTargetHost(), rt.getHopTarget(0), "wrong hop0 " + msg);
                 }
                 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);
                     Assertions.assertEquals(2, rt.getHopCount(), "wrong hop count " + msg);
                     Assertions.assertEquals(r.getProxyHost(), rt.getHopTarget(0), "wrong hop0 " + msg);
                     Assertions.assertEquals(r.getTargetHost(), rt.getHopTarget(1), "wrong hop1 " + msg);
                 }
                 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);
                     Assertions.assertEquals(hops, rt.getHopCount(), "wrong hop count " + msg);
                     Assertions.assertEquals(r.getProxyHost(), rt.getHopTarget(0), "wrong hop0 " + msg);
                     Assertions.assertEquals(r.getTargetHost(), rt.getHopTarget(hops - 1), "wrong hopN " + msg);
                 }
                 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);
                     Assertions.assertEquals(hops + 1, rt.getHopCount(), "wrong hop count " + msg);
                     Assertions.assertEquals(r.getProxyHost(), rt.getHopTarget(0), "wrong hop0 " + msg);
                     Assertions.assertEquals(pxy, rt.getHopTarget(hops - 1), "wrong hop" + hops + " " + msg);
                     Assertions.assertEquals(r.getTargetHost(), rt.getHopTarget(hops), "wrong hopN " + msg);
                 }
                 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);
                     Assertions.assertEquals(hops, rt.getHopCount(), "wrong hop count " + msg);
                     Assertions.assertEquals(r.getProxyHost(), rt.getProxyHost(), "wrong proxy " + msg);
                     Assertions.assertEquals(r.getTargetHost(), rt.getTargetHost(), "wrong target " + msg);
                 }
                 break;
 
 
                 // UNREACHABLE
                 default:
                     Assertions.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();
             Assertions.assertTrue(rts.contains(las), "no local address in toString(): " + rts);
         }
 
         for (int i = 0; i < rt.getHopCount(); i++) {
             final String hts = rt.getHopTarget(i).toString();
             Assertions.assertTrue(rts.contains(hts), "hop " + i + " (" + hts + ") missing in toString(): " + rts);
         }
 
         return rts;
     }
 
 }