assertCorrectSlice(0, 0, 0, 0);
    assertCorrectSlice(0, 0, 1, 0);
    assertCorrectSlice(100, 0, 10, 10);
    assertCorrectSlice(100, 0, 100, 100);
    assertCorrectSlice(100, 5, 10, 10);
    assertCorrectSlice(100, 5, 100, 95);
    assertCorrectSlice(100, 100, 0, 0);
    assertCorrectSlice(100, 100, 10, 0);
    assertCorrectSlice(100, 101, 10, 0);
  }

  /**

    assertFalse(InetAddresses.isUriInetAddress("1:2e"));
    assertFalse(InetAddresses.isUriInetAddress("[3ffe:0:0:0:0:0:0:1"));
    assertFalse(InetAddresses.isUriInetAddress("3ffe:0:0:0:0:0:0:1]"));
    assertFalse(InetAddresses.isUriInetAddress("3ffe:0:0:0:0:0:0:1"));
    assertFalse(InetAddresses.isUriInetAddress("::ffff:192.0.2.1"));
  }

  public void testForUriStringBad() {

		cpuUserVal := math.Round(ts.User/tot*100*100) / 100
		m.Set(sysCPUUser, cpuUserVal)
		cpuSystemVal := math.Round(ts.System/tot*100*100) / 100
		m.Set(sysCPUSystem, cpuSystemVal)
		cpuNiceVal := math.Round(ts.Nice/tot*100*100) / 100
		m.Set(sysCPUNice, cpuNiceVal)
		cpuStealVal := math.Round(ts.Steal/tot*100*100) / 100
		m.Set(sysCPUSteal, cpuStealVal)
	}

				cpuUserVal := math.Round(ts.User/tot*100*100) / 100
				updateResourceMetrics(cpuSubsystem, cpuUser, cpuUserVal, labels, false)
				cpuSystemVal := math.Round(ts.System/tot*100*100) / 100
				updateResourceMetrics(cpuSubsystem, cpuSystem, cpuSystemVal, labels, false)
				cpuIdleVal := math.Round(ts.Idle/tot*100*100) / 100
				updateResourceMetrics(cpuSubsystem, cpuIdle, cpuIdleVal, labels, false)

          .put(Hashing.murmur3_128(), TQBFJOTLDP, "c902e99e1f4899cde7b68789a3a15d69")
          .put(Hashing.murmur3_32(), "", "00000000")
          .put(Hashing.murmur3_32(), TQBFJOTLD, "23f74f2e")
          .put(Hashing.murmur3_32(), TQBFJOTLDP, "fc8bc4d5")
          .put(Hashing.murmur3_32_fixed(), "", "00000000")
          .put(Hashing.murmur3_32_fixed(), TQBFJOTLD, "23f74f2e")
          .put(Hashing.murmur3_32_fixed(), TQBFJOTLDP, "fc8bc4d5")

	longName := "/0000_0000000/00000-000000000/0000_0000000/00000-0000000000000/0000_0000000/00000-0000000-00000000/0000_0000000/00000000/0000_0000000/000/0000_0000000/00000000v00/0000_0000000/000000/0000_0000000/0000000/0000_0000000/00000y-00/0000/0000/00000000/0x000000/"
	hdr.Name = longName

	hdr.Size = 0
	var buf bytes.Buffer
	writer := NewWriter(&buf)

        .withValueStrengths(ImmutableSet.copyOf(Strength.values()))
        .withConcurrencyLevels(ImmutableSet.of(1, 4, 16, 64))
        .withMaximumSizes(ImmutableSet.of(400, 1000))
        .withInitialCapacities(ImmutableSet.of(0, 1, 10, 100, 1000))
        .withExpireAfterWrites(
            ImmutableSet.of(
                // DurationSpec.of(500, MILLISECONDS),

	BFPT	lable1	// BFPT 2	//1ffdff4b

lable2:
	BFPF	1(PC)			// 00040048
	BFPF	lable2	// BFPF 4 	// 1ffcff4b

	// relocation in play so the assembled offset should be 0
	JMP	foo(SB)			// 00000050

	JMP	(R4)			// 8000004c
	JMP	1(PC)			// 00040050
	MOVW	$65536, R4		// 04020014
	MOVW	$4096, R4		// 24000014
	MOVV	$65536, R4		// 04020014
	MOVV	$4096, R4		// 24000014
	MOVW	R4, R5			// 85001700
	MOVV	R4, R5			// 85001500

	}
}

func Test_localLocker_expireOldLocksExpire(t *testing.T) {
	rng := rand.New(rand.NewSource(0))
	quorum := 0
	// Numbers of unique locks
	for _, locks := range []int{100, 1000, 1e6} {
		if testing.Short() && locks > 100 {
			continue
		}
		t.Run(fmt.Sprintf("%d-locks", locks), func(t *testing.T) {
			// Number of readers per lock...
			for _, readers := range []int{1, 10, 100} {

	for i, elt := range e.Elements {
		v, err := elt.evalNode(r, tableAlias)
		if err != nil {
			return nil, err
		}
		res[i] = *v
	}
	return FromArray(res), nil
}

const floatCmpTolerance = 0.000001

func (e *In) evalInNode(r Record, lhs *Value, tableAlias string) (*Value, error) {
	// Compare two values in terms of in-ness.
	var cmp func(a, b Value) bool
	cmp = func(a, b Value) bool {
		// Convert if needed.