int minLen = Math.min(nodeLabelLen, labelLen);
    for (int i = 0; i < minLen; i++) {
      char c1 = label.charAt(i);
      char c2 = stringPool.charAt(offset + 1 + i);
      if (c1 != c2) {
        return c1 - c2;
      }
    }
    return labelLen - nodeLabelLen;
  }

  /**
   * A CharSequence that is composed of multiple chunks. This is used to work around the 64k size

      table.put("r" + i, "c" + i, "v" + i);
    }
    assertThat(table.rowKeySet()).containsExactly("r0", "r1", "r2", "r3", "r4").inOrder();
    assertThat(table.columnKeySet()).containsExactly("c0", "c1", "c2", "c3", "c4").inOrder();
    assertThat(table.values()).containsExactly("v0", "v1", "v2", "v3", "v4").inOrder();
  }

  public void testCreateWithValidSizes() {

      char c1 = s1.charAt(i);
      char c2 = s2.charAt(i);
      if (c1 == c2) {
        continue;
      }
      int alphaIndex = getAlphaIndex(c1);
      // This was also benchmarked using '&' to avoid branching (but always evaluate the rhs),
      // however this showed no obvious improvement.
      if (alphaIndex < 26 && alphaIndex == getAlphaIndex(c2)) {
        continue;
      }
      return false;

        assertEscaping(e, escapeAscii(c), c);
      }
    }

    // Testing multibyte escape sequences
    assertEscaping(e, "%00", '\u0000'); // nul
    assertEscaping(e, "%7F", '\u007f'); // del
    assertEscaping(e, "%C2%80", '\u0080'); // xx-00010,x-000000
    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000

    assertUnescaped(e, '_');
    assertUnescaped(e, '.');
    assertUnescaped(e, '*');

    assertEscaping(e, "%00", '\u0000'); // nul
    assertEscaping(e, "%7F", '\u007f'); // del
    assertEscaping(e, "%C2%80", '\u0080'); // xx-00010,x-000000
    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000

	}
	val := p.actionsLatency[a].total()
	return val
}

// setCycle updates the current cycle metrics.
func (p *scannerMetrics) setCycle(c *currentScannerCycle) {
	if c != nil {
		c2 := c.clone()
		c = &c2
	}
	p.cycleInfoMu.Lock()
	p.cycleInfo = c
	p.cycleInfoMu.Unlock()
}

// getCycle returns the current cycle metrics.
// If not nil, the returned value can safely be modified.

    assertUnescaped(e, '_');
    assertUnescaped(e, '.');
    assertUnescaped(e, '*');

    assertEscaping(e, "%00", '\u0000'); // nul
    assertEscaping(e, "%7F", '\u007f'); // del
    assertEscaping(e, "%C2%80", '\u0080'); // xx-00010,x-000000
    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000

  }

  @Test
  fun cancelingRunningJobTakesNoEffectUntilJobFinishes() {
    dispatcher.maxRequests = 1
    val c1 = client.newCall(newRequest("http://a/1", "tag1"))
    val c2 = client.newCall(newRequest("http://a/2"))
    c1.enqueue(callback)
    c2.enqueue(callback)
    c1.cancel()
    executor.assertJobs("http://a/1")
    executor.finishJob("http://a/1")
    executor.assertJobs("http://a/2")
  }

  @Test

                return channels.get(index);

            case LEAST_CONNECTIONS:
                return channels.stream()
                        .min((c1, c2) -> Integer.compare(c1.getActiveConnections(), c2.getActiveConnections()))
                        .orElse(channels.get(0));

            case RANDOM:
                return channels.get((int) (Math.random() * channels.size()));

        assertEscaping(e, escapeAscii(c), c);
      }
    }

    // Testing multibyte escape sequences
    assertEscaping(e, "%00", '\u0000'); // nul
    assertEscaping(e, "%7F", '\u007f'); // del
    assertEscaping(e, "%C2%80", '\u0080'); // xx-00010,x-000000
    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000