public void Covers_should_be_true_if_big_value_gt_end()
{
var range = new HashRange(0, BigInteger.Parse("45671926166590716193865151022383844364247891967"));
var value = BigInteger.Parse("294255062699127052481571644205017775360447081995");
range.Covers(value).Should().BeFalse();
}
public void Covers_should_be_true_if_big_value_lt_end()
{
var range = new HashRange(0, BigInteger.Parse("45671926166590716193865151022383844364247891967"));
var value = BigInteger.Parse("45671926166590716193865151022383844364247891966");
range.Covers(value).Should().BeTrue();
}
public void ContainsTest()
{
var range = new HashRange(MD5Hash.MinValue, MD5Hash.MaxValue);
var ranges = HashRange.SegmentRange(range, new decimal[] { 0.50m, 0.50m });
var start1 = new MD5Hash("00000000000000000000000000000000");
var start2 = new MD5Hash("80000000000000000000000000000000");
var end1 = new MD5Hash("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
var end2 = new MD5Hash("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
Assert.IsTrue(ranges.Length == 2);
Assert.IsTrue(ranges[0].Contains(start1));
Assert.IsTrue(ranges[0].Contains(end1));
Assert.IsTrue(ranges[1].Contains(start2));
Assert.IsTrue(ranges[1].Contains(end2));
Assert.IsFalse(ranges[0].Contains(start2));
Assert.IsFalse(ranges[0].Contains(end2));
Assert.IsFalse(ranges[1].Contains(start1));
Assert.IsFalse(ranges[1].Contains(end1));
Assert.IsTrue(start1 < end1);
Assert.IsTrue(end1 < start2);
Assert.IsTrue(start2 < end2);
Assert.IsFalse(start1 > end1);
Assert.IsFalse(end1 > start2);
Assert.IsFalse(start2 > end2);
}
public void ContainsTest()
{
var range = new HashRange(10, 15);
for (uint i = 11; i <= 15; i++)
{
range.Contains(i).Should().BeTrue();
}
range.Contains(10).Should().BeFalse();
range.Contains(16).Should().BeFalse();
}
public void WrapAroundContains()
{
var range = new HashRange(uint.MaxValue - 10, 10);
range.Contains(uint.MaxValue - 10).Should().BeFalse();
foreach (uint i in new WrappingRange(range))
{
range.Contains(i).Should().BeTrue();
}
range.Contains(11).Should().BeFalse();
}
public void GetBigIntegerFromBytesTest()
{
var a = MD5Hash.MaxValue.Values;
var b = MD5Hash.MinValue.Values;
var c = new MD5Hash("A0000000000000A00000000000000000").Values;
Assert.IsTrue(a.SequenceEqual(HashRange.GetBytesFromBigInteger(HashRange.GetBigIntegerFromBytes(a),
MD5Hash.ExpectedByteLength)));
Assert.IsTrue(b.SequenceEqual(HashRange.GetBytesFromBigInteger(HashRange.GetBigIntegerFromBytes(b),
MD5Hash.ExpectedByteLength)));
Assert.IsTrue(c.SequenceEqual(HashRange.GetBytesFromBigInteger(HashRange.GetBigIntegerFromBytes(c),
MD5Hash.ExpectedByteLength)));
}
public void SegmentRangeTest()
{
var range = new HashRange(MD5Hash.MinValue, MD5Hash.MaxValue);
var ranges = HashRange.SegmentRange(range, new decimal[] { 0.50m, 0.50m });
Assert.IsTrue(ranges[0].MinHash == new MD5Hash("00000000000000000000000000000000"),
ranges[0].MinHash + " " + ranges[0].MaxHash);
Assert.IsTrue(ranges[0].MaxHash == new MD5Hash("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
ranges[0].MinHash + " " + ranges[0].MaxHash);
Assert.IsTrue(ranges[1].MinHash == new MD5Hash("80000000000000000000000000000000"),
ranges[1].MinHash + " " + ranges[1].MaxHash);
Assert.IsTrue(ranges[1].MaxHash == new MD5Hash("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
ranges[1].MinHash + " " + ranges[1].MaxHash);
}
public void WrapAroundRange()
{
var wrapAround = new HashRange(uint.MaxValue - 10, 5);
var coll = new HashRangeCollection(
new HashRange[]
{
new HashRange(10, 20),
wrapAround,
});
for (uint i = 11; i <= 20; i++)
{
coll.Contains(i).Should().BeTrue();
}
foreach (uint i in new WrappingRange(wrapAround))
{
coll.Contains(i).Should().BeTrue($"{i} in ({uint.MaxValue - 10}, 5]");
}
}
/// <summary>
/// Creates a new partition with the specified node and hash range.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="range">The range.</param>
public Partition(TNode node, HashRange range)
{
this.Node = node;
this.Range = range;
}
public void Covers_should_be_false_if_value_gt_end()
{
var range = new HashRange(0, 10);
range.Covers(11).Should().BeFalse();
}
public void Covers_should_be_false_if_value_lt_start()
{
var range = new HashRange(0, 10);
range.Covers(-1).Should().BeFalse();
}
public void Covers_should_be_true_if_value_lt_end()
{
var range = new HashRange(0, 10);
range.Covers(8).Should().BeTrue();
}
public void Covers_should_be_true_if_value_gt_start()
{
var range = new HashRange(0, 10);
range.Covers(2).Should().BeTrue();
}
public IndexHeader(HashRange range, int? mode)
{
this.Range = range;
this.Mode = mode;
}
public WrappingRange(HashRange range) : this(range.StartExclusive, range.EndInclusive)
{
}
