docs: private void printTimeOfMapMatchQuery(final GraphHopper hopper, final MapMatching mapMatching) {
  
          // pick random start/end points to create a route, then pick random points from the route,
          // and then run the random points through map-matching.
          final double latDelta = bbox.maxLat - bbox.minLat;
          final double lonDelta = bbox.maxLon - bbox.minLon;
          final Random rand = new Random(seed);
          MiniPerfTest miniPerf = new MiniPerfTest() {
              @Override
              public int doCalc(boolean warmup, int run) {
                  // keep going until we find a path (which we may not for certain start/end points)
                  while (true) {
                      // create random points and find route between:
                      double lat0 = bbox.minLat + rand.nextDouble() * latDelta;
                      double lon0 = bbox.minLon + rand.nextDouble() * lonDelta;
                      double lat1 = bbox.minLat + rand.nextDouble() * latDelta;
                      double lon1 = bbox.minLon + rand.nextDouble() * lonDelta;
                      GHResponse r = hopper.route(new GHRequest(lat0, lon0, lat1, lon1));
  
                      // if found, use it for map matching:
                      if (!r.hasErrors()) {
                          double sampleProportion = rand.nextDouble();
                          GHPoint prev = null;
                          List<Observation> mock = new ArrayList<>();
                          PointList points = r.getBest().getPoints();
                          // loop through points and add (approximately) sampleProportion of them:
                          for (GHPoint p : points) {
                              if (null != prev && rand.nextDouble() < sampleProportion) {
                                  // randomise the point lat/lon (i.e. so it's not
                                  // exactly on the route):
                                  GHPoint randomised = distCalc.projectCoordinate(p.lat, p.lon,
                                          20 * rand.nextDouble(), 360 * rand.nextDouble());
                                  mock.add(new Observation(randomised));
                              }
                              prev = p;
                          }
                          // now match, provided there are enough points
                          if (mock.size() > 2) {
                              MatchResult match = mapMatching.doWork(mock);
                              // return something non-trivial, to avoid JVM optimizing away
                              return match.getEdgeMatches().size();
                          }
                      }
                  }
              }
          }.setIterations(count).start();
          print("map_match", miniPerf);
      }