public void SingleRemove(int margin)
{
var i = new MappedInterval <Crate>(0, 100, MakeDummy(0));
_sut.Put(new [] { i });
_sut.Delete(i.IntervalStart - margin, i.IntervalEnd + margin);
Assert.That(_sut.Count, Is.Zero);
}
private void AddIntervals(params MappedInterval <Crate>[] intervals)
{
var box = new MappedInterval <Crate> [1];
foreach (var i in intervals)
{
box[0] = i;
_sut.Put(box);
}
}
public void Work()
{
var collection = Collection;
var box = new MappedInterval <TPayload> [1];
for (var i = 0; i < _input.Length; ++i)
{
box[0] = _input[i];
collection.Put(box);
}
}
public Hueta(MappedInterval <T> interval, bool?isStart)
{
Interval = interval;
if (isStart.HasValue)
{
IsStart = isStart.Value;
}
else
{
IsStart = null;
}
}
public static Tuple <long, long> Fill <TPayload>(Sorting sorting, Overlapping overlapping, TPayload filler, MappedInterval <TPayload>[] output)
{
var count = output.Length;
var start = 0L;
var duration = 10L;
var step = overlapping == Overlapping.Yes ? duration >> 1 : duration << 1;
var min = long.MaxValue;
var max = long.MinValue;
switch (sorting)
{
case Sorting.Ascending:
case Sorting.Descending:
{
var from = sorting == Sorting.Ascending ? 0 : count - 1;
var to = sorting == Sorting.Ascending ? count : 0;
var delta = sorting == Sorting.Ascending ? 1 : -1;
while (from != to)
{
min = Math.Min(min, start);
max = Math.Max(max, start + duration);
output[from] = new MappedInterval <TPayload>(start, start + duration, filler);
start += step;
from += delta;
}
break;
}
case Sorting.Random:
{
var durationFrom = (int)(duration - duration * 0.2);
var durationTo = (int)(duration + duration * 0.2);
var r = new Random(0xDEAD);
for (var i = 0; i < count; ++i)
{
var s = r.Next(0, int.MaxValue);
var d = r.Next(durationFrom, durationTo);
min = Math.Min(min, s);
max = Math.Max(max, s + d);
output[i] = new MappedInterval <TPayload>(s, s + d, filler);
}
break;
}
}
return(Tuple.Create(min, max));
}
public void Ascending(DataSource source, DataFilter filter)
{
var input = new MappedInterval <Crate> [10];
DataGeneration.LikeReal(source, filter, MakeCrate, input);
var whole = new Tuple <int, int> [1];
whole[0] = Tuple.Create(0, input.Length);
AddSeries(input, whole);
CollectionAssert.AreEqual(_sut, input);
}
private void AddSeries(IReadOnlyList <MappedInterval <Crate> > input, IReadOnlyList <Tuple <int, int> > ranges)
{
var box = new MappedInterval <Crate> [1];
foreach (var range in ranges)
{
for (var i = range.Item1; i < range.Item2; ++i)
{
box[0] = input[i];
_sut.Put(box);
}
}
}
protected void AddSeries(IReadOnlyList <MappedInterval <TPayload> > input, IReadOnlyList <Tuple <int, int> > ranges)
{
var collection = Collection;
var box = new MappedInterval <TPayload> [1];
foreach (var range in ranges)
{
for (var i = range.Item1; i < range.Item2; ++i)
{
box[0] = input[i];
collection.Put(box);
}
}
}
public int Compare(MappedInterval <T> x, MappedInterval <T> y)
{
if (x.IntervalStart < y.IntervalStart && x.IntervalEnd <= y.IntervalStart)
{
return(-1);
}
if (y.IntervalStart < x.IntervalStart && y.IntervalEnd <= x.IntervalStart)
{
return(1);
}
return(0);
}
public void RandomAscendingSeries(DataSource source, DataFilter filter)
{
var input = new MappedInterval <Crate> [10];
DataGeneration.LikeReal(source, filter, MakeCrate, input);
var preRanges = GeneratePartitions(input.Length).ToArray();
var ranges = new Tuple <int, int> [preRanges.Length];
Shuffle(preRanges, ranges);
AddSeries(input, ranges);
CollectionAssert.AreEqual(_sut, input);
}
public void OverwritingUpdate()
{
var input = IntervalGeneration.Sequence(0, 10, 5, 5, MakeDummy).ToArray();
var space = new MappedInterval <Crate> [1];
foreach (var i in input)
{
space[0] = i;
_sut.Put(space);
}
var output = _sut.ToArray();
var expectedOutput = IntervalGeneration.Sequence(0, 5, 5, input.Length - 1, i => input[i].Payload).Concat(input.Skip(input.Length - 1));
CollectionAssert.AreEqual(expectedOutput, output);
}
private static IEnumerable <MappedInterval <T> > Rebuild(IEnumerable <MappedInterval <T> > current, IEnumerable <MappedInterval <T> > addition)
{
var set = GhettoMergeSort(current, addition);
MappedInterval <T>?pending = null;
foreach (var i in set)
{
if (!pending.HasValue)
{
pending = i;
continue;
}
if (i.Payload.Equals(pending.Value.Payload))
{
if (pending.Value.IntervalEnd >= i.IntervalStart)
{
pending = new MappedInterval <T>(pending.Value.IntervalStart, i.IntervalEnd, i.Payload);
continue;
}
yield return(pending.Value);
pending = i;
continue;
}
if (pending.Value.IntervalEnd >= i.IntervalStart)
{
yield return(new MappedInterval <T>(pending.Value.IntervalStart, i.IntervalStart, pending.Value.Payload));
}
else
{
yield return(pending.Value);
}
pending = i;
}
if (pending.HasValue)
{
yield return(pending.Value);
}
}
public void RandomSeriesBatched(DataSource source, DataFilter filter)
{
var input = new MappedInterval <Crate> [10];
DataGeneration.LikeReal(source, filter, MakeCrate, input);
var preRanges = GeneratePartitions(input.Length).ToArray();
var ranges = new Tuple <int, int> [preRanges.Length];
Shuffle(preRanges, ranges);
foreach (var range in ranges)
{
_sut.Put(new ArraySegment <MappedInterval <Crate> >(input, range.Item1, range.Item2 - range.Item1));
}
CollectionAssert.AreEqual(_sut, input);
}
private static void MakeSpacedIntervals <TPayload>(Description description, Func <int, TPayload> makePayload, MappedInterval <TPayload>[] output)
{
var r = new Random(0xBADDAD);
var start = MakeGap();
for (var i = 0; i < output.Length; ++i)
{
start += MakeGap();
var duration = MakeInterval();
var from = ToUsec(start);
var to = from + duration;
output[i] = new MappedInterval <TPayload>(from, to, makePayload(i));
}
int MakeInterval() => r.Next(description.IntervalRange.Item1, description.IntervalRange.Item2);
int MakeGap() => r.Next(description.GapRange.Item1, description.GapRange.Item2);
long ToUsec(int msec) => msec * 1000 - r.Next(0, 3);
}
public void PartialRemove()
{
var i = new MappedInterval <Crate>(0, 1000, MakeDummy(0));
_sut.Put(new [] { i });
var gapFrom = 100;
var gapTo = 400;
_sut.Delete(gapFrom, gapTo);
var output = _sut.ToArray();
Assert.That(output.Length, Is.EqualTo(2));
Assert.That(output[0].Payload.Value, Is.EqualTo(0));
Assert.That(output[0].IntervalStart, Is.EqualTo(i.IntervalStart));
Assert.That(output[0].IntervalEnd, Is.EqualTo(gapFrom));
Assert.That(output[1].Payload.Value, Is.EqualTo(0));
Assert.That(output[1].IntervalStart, Is.EqualTo(gapTo));
Assert.That(output[1].IntervalEnd, Is.EqualTo(i.IntervalEnd));
}
protected override void AfterCollectionCreation()
{
var dummy = new TPayload();
var box = new MappedInterval <TPayload> [1];
switch (InitialState)
{
case PreDeleteState.OneBigInterval:
box[0] = new MappedInterval <TPayload>(0, long.MaxValue, dummy);
Collection.Put(box);
break;
case PreDeleteState.LotsOfSmallIntervals:
case PreDeleteState.Random:
var inputs = new MappedInterval <TPayload> [Count];
var sorting = InitialState == PreDeleteState.Random ? Sorting.Random : Sorting.Ascending;
DataGeneration.Fill(sorting, Overlapping.No, dummy, inputs);
Collection.Put(inputs);
break;
}
base.AfterCollectionCreation();
}
private static IEnumerable <MappedInterval <T> > GhettoMergeSort(IEnumerable <MappedInterval <T> > current, IEnumerable <MappedInterval <T> > addition)
{
using (var existingEnumerator = current.GetEnumerator())
using (var addedEnumerator = addition.GetEnumerator())
{
IEnumerator <MappedInterval <T> > tail;
MappedInterval <T>?existing = null;
MappedInterval <T>?added = null;
while (true)
{
if (!existing.HasValue)
{
if (!existingEnumerator.MoveNext())
{
tail = addedEnumerator;
break;
}
existing = existingEnumerator.Current;
}
while (addedEnumerator.MoveNext())
{
added = addedEnumerator.Current;
if (added.Value.IntervalStart < existing.Value.IntervalStart)
{
yield return(added.Value);
added = null;
continue;
}
break;
}
yield return(existing.Value);
existing = null;
if (!added.HasValue)
{
tail = existingEnumerator;
break;
}
while (existingEnumerator.MoveNext())
{
existing = existingEnumerator.Current;
if (existing.Value.IntervalStart < added.Value.IntervalStart)
{
yield return(existing.Value);
existing = null;
continue;
}
break;
}
yield return(added.Value);
added = null;
}
while (tail.MoveNext())
{
yield return(tail.Current);
}
}
}
private static bool AcceptNode <T>(MappedInterval <T> node, int from, int to)
{
return(node.IntervalEnd >= from && node.IntervalStart <= to);
}
