private void SplitByGrid_OneStep_SinglePart(ITimeSpan gridStart, ITimeSpan step, TempoMap tempoMap)
{
var gridSteps = new[] { step };
var firstTime = TimeConverter.ConvertFrom(gridStart, tempoMap);
long secondTime = firstTime;
for (int i = 0; i < 5; i++)
{
secondTime += LengthConverter.ConvertFrom(step, secondTime, tempoMap);
}
var inputObjects = new[]
{
ObjectMethods.Create(firstTime, LengthConverter.ConvertFrom(step, firstTime, tempoMap)),
ObjectMethods.Create(secondTime, LengthConverter.ConvertFrom(step, secondTime, tempoMap))
};
var data = SplitByGrid_ClonesExpected(inputObjects, gridStart, gridSteps, tempoMap);
var stepType = TimeSpanTypes[step.GetType()];
var partLength = data.ActualObjects.First().LengthAs(stepType, tempoMap);
Assert.IsTrue(data.ActualObjects.All(o => o.LengthAs(stepType, tempoMap).Equals(partLength)),
$"Objects have different length measured as {stepType}.");
}
public void SplitByGrid_MultipleSteps_AwayFromZero_Musical()
{
var tempoMap = TempoMap.Default;
var obj1 = ObjectMethods.Create(new MusicalTimeSpan(), MusicalTimeSpan.Whole, tempoMap);
var obj2 = ObjectMethods.Create(new MusicalTimeSpan(5, 8), 10 * MusicalTimeSpan.Eighth, tempoMap);
SplitByGrid_MultipleSteps(
inputObjects: new[] { obj1, obj2 },
gridStart: MusicalTimeSpan.Half,
gridSteps: new[]
{
MusicalTimeSpan.Eighth,
MusicalTimeSpan.Whole
},
expectedParts: new Dictionary <TObject, IEnumerable <TimeAndLength> >
{
[obj1] = new[]
{
new TimeAndLength(new MusicalTimeSpan(), MusicalTimeSpan.Half),
new TimeAndLength(MusicalTimeSpan.Half, MusicalTimeSpan.Eighth),
new TimeAndLength(MusicalTimeSpan.Half + MusicalTimeSpan.Eighth, 3 * MusicalTimeSpan.Eighth)
},
[obj2] = new[]
{
new TimeAndLength(new MusicalTimeSpan(5, 8), MusicalTimeSpan.Whole),
new TimeAndLength(13 * MusicalTimeSpan.Eighth, MusicalTimeSpan.Eighth),
new TimeAndLength(14 * MusicalTimeSpan.Eighth, MusicalTimeSpan.Eighth)
}
},
tempoMap: tempoMap);
}
protected override Expression <Func <TFrom, TTo, TTo> > CompileToExpression()
{
var allConversions = this.aConversions.ToList();
var from = Expression.Parameter(typeof(TFrom), "from");
var to = Expression.Parameter(typeof(TTo), "to");
return(Expression.Lambda <Func <TFrom, TTo, TTo> >(
Expression.Block(
Expression.Switch(
typeof(void),
Expression.Call(from, ObjectMethods.GetType()),
Expression.Throw(
Expression.New(
typeof(UnknownMappingException).GetConstructor(new Type[] { typeof(Type), typeof(Type) }),
Expression.Call(from, ObjectMethods.GetType()),
Expression.Constant(typeof(TTo))
)
),
null,
allConversions.Select(x => this.MakeIfConvertSynchronizeStatement(x.From, x.To, x.Mapping.ResolvedMapping, from, to))
),
to
),
from, to
));
}
public void SplitByStep_UnequalDivision()
{
var tempoMap = TempoMap.Default;
var partsNumber = 10;
var step = 1000L;
var inputObjects = CreateInputObjects(step * (partsNumber - 1) + step / 2).ToArray();
var expectedObjects = inputObjects.SelectMany(o => Split(o, Enumerable.Range(1, partsNumber - 1).Select(i => o.Time + step * i)));
var actualObjects = Splitter.SplitByStep(inputObjects, (MidiTimeSpan)step, tempoMap).ToArray();
Assert.AreEqual(inputObjects.Length * partsNumber,
actualObjects.Length,
"Parts count is invalid.");
Assert.IsTrue(Enumerable.Range(0, inputObjects.Length)
.SelectMany(i => actualObjects.Skip(partsNumber * i)
.Take(partsNumber - 1))
.All(o => o.Length == step),
"Length of some objects (except the last one) doesn't equal to the step.");
Assert.IsTrue(Enumerable.Range(0, inputObjects.Length)
.All(i => actualObjects.Skip(partsNumber * i)
.Take(partsNumber)
.Last()
.Length < step),
"Last object's length is not less than the step.");
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
private TObject CloneAndChangeTimeAndLength(TObject obj, long time, long length)
{
var result = ObjectMethods.Clone(obj);
ObjectMethods.SetTime(result, time);
ObjectMethods.SetLength(result, length);
return(result);
}
private void Randomize_Start(IEnumerable <TObject> actualObjects, IBounds bounds, IEnumerable <TimeBounds> expectedBounds, TempoMap tempoMap)
{
for (int i = 0; i < RepeatRandomizationCount; i++)
{
var clonedActualObjects = actualObjects.Select(o => o != null ? ObjectMethods.Clone(o) : default(TObject)).ToList();
Randomize(LengthedObjectTarget.Start, clonedActualObjects, bounds, expectedBounds, tempoMap);
}
}
private SplitData SplitByGrid_ClonesExpected(IEnumerable <TObject> inputObjects, ITimeSpan gridStart, IEnumerable <ITimeSpan> gridSteps, TempoMap tempoMap)
{
var expectedObjects = inputObjects.Select(o => o == null ? default(TObject) : ObjectMethods.Clone(o)).ToArray();
var actualObjects = Splitter.SplitByGrid(inputObjects, new SteppedGrid(gridStart, gridSteps), tempoMap).ToArray();
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
return(new SplitData(inputObjects, expectedObjects, actualObjects));
}
public void SplitAtDistance_EmptyCollection(LengthedObjectTarget from)
{
var tempoMap = TempoMap.Default;
var inputObjects = Enumerable.Empty <TObject>();
var distance = (MidiTimeSpan)100;
var expectedObjects = Enumerable.Empty <TObject>();
var actualObjects = Splitter.SplitAtDistance(inputObjects, distance, from, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitByPartsNumber_ZeroLength()
{
var tempoMap = TempoMap.Default;
var inputObjects = CreateInputObjects(0);
var partsNumber = 10;
var expectedObjects = inputObjects.SelectMany(o => Enumerable.Range(0, partsNumber).Select(i => ObjectMethods.Clone(o)));
var actualObjects = Splitter.SplitByPartsNumber(inputObjects, partsNumber, TimeSpanType.Midi, tempoMap).ToArray();
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitByPartsNumber_OnePart()
{
var tempoMap = TempoMap.Default;
var inputObjects = CreateInputObjects(100);
var partsNumber = 1;
var expectedObjects = inputObjects.Select(o => ObjectMethods.Clone(o));
var actualObjects = Splitter.SplitByPartsNumber(inputObjects, partsNumber, TimeSpanType.Midi, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitByPartsNumber_Nulls()
{
var tempoMap = TempoMap.Default;
var inputObjects = new[] { default(TObject), default(TObject) };
var partsNumber = 100;
var expectedObjects = new[] { default(TObject), default(TObject) };
var actualObjects = Splitter.SplitByPartsNumber(inputObjects, partsNumber, TimeSpanType.Midi, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitByPartsNumber_EmptyCollection()
{
var tempoMap = TempoMap.Default;
var inputObjects = Enumerable.Empty <TObject>();
var partsNumber = 100;
var expectedObjects = Enumerable.Empty <TObject>();
var actualObjects = Splitter.SplitByPartsNumber(inputObjects, partsNumber, TimeSpanType.Midi, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitByStep_StepEqualObjectsLength()
{
var tempoMap = TempoMap.Default;
var step = 1000L;
var inputObjects = CreateInputObjects(step);
var expectedObjects = inputObjects.Select(o => ObjectMethods.Clone(o));
var actualObjects = Splitter.SplitByStep(inputObjects, (MidiTimeSpan)step, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitAtDistance_Nulls(LengthedObjectTarget from)
{
var tempoMap = TempoMap.Default;
var inputObjects = new[] { default(TObject), default(TObject) };
var distance = (MidiTimeSpan)100;
var expectedObjects = new[] { default(TObject), default(TObject) };
var actualObjects = Splitter.SplitAtDistance(inputObjects, distance, from, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitAtDistance_BigDistance(LengthedObjectTarget from)
{
var tempoMap = TempoMap.Default;
var inputObjects = CreateInputObjects(1000);
var distance = (MidiTimeSpan)1000;
var expectedObjects = inputObjects.Select(o => ObjectMethods.Clone(o));
var actualObjects = Splitter.SplitAtDistance(inputObjects, distance, from, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitByStep_Nulls()
{
var tempoMap = TempoMap.Default;
var inputObjects = new[] { default(TObject), default(TObject) };
var step = (MidiTimeSpan)100;
var expectedObjects = new[] { default(TObject), default(TObject) };
var actualObjects = Splitter.SplitByStep(inputObjects, step, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitAtDistance_FullLengthRatio(LengthedObjectTarget from)
{
var tempoMap = TempoMap.Default;
var inputObjects = CreateInputObjects(1000);
var ratio = 1.0;
var expectedObjects = inputObjects.Select(o => ObjectMethods.Clone(o));
var actualObjects = Splitter.SplitAtDistance(inputObjects, ratio, TimeSpanType.Midi, from, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitAtDistance_ByRatio_End()
{
var tempoMap = TempoMap.Default;
var inputObjects = CreateInputObjects(1000);
var ratio = 0.1;
var expectedObjects = inputObjects.SelectMany(o => Split(o, new[] { o.Time + o.Length - 100 }));
var actualObjects = Splitter.SplitAtDistance(inputObjects, ratio, TimeSpanType.Midi, LengthedObjectTarget.End, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitByStep_EmptyCollection()
{
var tempoMap = TempoMap.Default;
var inputObjects = Enumerable.Empty <TObject>();
var step = (MidiTimeSpan)100;
var expectedObjects = Enumerable.Empty <TObject>();
var actualObjects = Splitter.SplitByStep(inputObjects, step, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitAtDistance_ByRatio_Nulls(LengthedObjectTarget from)
{
var tempoMap = TempoMap.Default;
var inputObjects = new[] { default(TObject), default(TObject) };
var ratio = 0.5;
var expectedObjects = new[] { default(TObject), default(TObject) };
var actualObjects = Splitter.SplitAtDistance(inputObjects, ratio, TimeSpanType.Midi, from, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitAtDistance_ByRatio_EmptyCollection(LengthedObjectTarget from)
{
var tempoMap = TempoMap.Default;
var inputObjects = Enumerable.Empty <TObject>();
var ratio = 0.5;
var expectedObjects = Enumerable.Empty <TObject>();
var actualObjects = Splitter.SplitAtDistance(inputObjects, ratio, TimeSpanType.Midi, from, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
public void SplitAtDistance_End()
{
var tempoMap = TempoMap.Default;
var inputObjects = CreateInputObjects(1000);
var distance = (MidiTimeSpan)10;
var expectedObjects = inputObjects.SelectMany(o => Split(o, new[] { o.Time + o.Length - distance }));
var actualObjects = Splitter.SplitAtDistance(inputObjects, distance, LengthedObjectTarget.End, tempoMap);
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
private SplitData SplitByPartsNumber(long objectsLength, int partsNumber, TimeSpanType lengthType, TempoMap tempoMap)
{
var inputObjects = CreateInputObjects(objectsLength).ToArray();
var expectedObjects = GetExpectedObjectsByPartsNumber(inputObjects, partsNumber).ToArray();
var actualObjects = Splitter.SplitByPartsNumber(inputObjects, partsNumber, lengthType, tempoMap).ToArray();
Assert.AreEqual(inputObjects.Length * partsNumber,
actualObjects.Length,
"Parts count is invalid.");
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
return(new SplitData(inputObjects, expectedObjects, actualObjects));
}
private IEnumerable <TObject> Split(TObject obj, IEnumerable <long> times)
{
var tail = ObjectMethods.Clone(obj);
foreach (var time in times.OrderBy(t => t))
{
var parts = SplitObject(tail, time);
yield return(parts.LeftPart);
tail = parts.RightPart;
}
yield return(tail);
}
public void SplitByGrid_MultipleSteps_AwayFromZero_Metric()
{
// 0:0:1.500
// │######║#################║########│
// . . 0:0:2.250
// . . │###║###########║#################║###########║#│
// . . | . | . . . |
// . . 0:0:1.150 0:0:1.500 . 0:0:3.400
// . . | . | . . . |
// . |=================|===========|=================|===========|=================|
// . | 0:0:1 | 0:0:0.350 | 0:0:1 | 0:0:0.350 | 0:0:1 |
// | | | | | | |
// 0 0:0:0.300 0:0:1.300 0:0:1.650 0:0:2.650 0:0:3 0:0:4
var tempoMap = TempoMap.Default;
var obj1 = ObjectMethods.Create(new MetricTimeSpan(),
new MetricTimeSpan(0, 0, 1, 500),
tempoMap);
var obj2 = ObjectMethods.Create(new MetricTimeSpan(0, 0, 1, 150),
new MetricTimeSpan(0, 0, 2, 250),
tempoMap);
SplitByGrid_MultipleSteps(
inputObjects: new[] { obj1, obj2 },
gridStart: new MetricTimeSpan(0, 0, 0, 300),
gridSteps: new[]
{
new MetricTimeSpan(0, 0, 1),
new MetricTimeSpan(0, 0, 0, 350)
},
expectedParts: new Dictionary <TObject, IEnumerable <TimeAndLength> >
{
[obj1] = new[]
{
new TimeAndLength(new MetricTimeSpan(), new MetricTimeSpan(0, 0, 0, 300)),
new TimeAndLength(new MetricTimeSpan(0, 0, 0, 300), new MetricTimeSpan(0, 0, 1)),
new TimeAndLength(new MetricTimeSpan(0, 0, 1, 300), new MetricTimeSpan(0, 0, 0, 200))
},
[obj2] = new[]
{
new TimeAndLength(new MetricTimeSpan(0, 0, 1, 150), new MetricTimeSpan(0, 0, 0, 150)),
new TimeAndLength(new MetricTimeSpan(0, 0, 1, 300), new MetricTimeSpan(0, 0, 0, 350)),
new TimeAndLength(new MetricTimeSpan(0, 0, 1, 650), new MetricTimeSpan(0, 0, 1)),
new TimeAndLength(new MetricTimeSpan(0, 0, 2, 650), new MetricTimeSpan(0, 0, 0, 350)),
new TimeAndLength(new MetricTimeSpan(0, 0, 3), new MetricTimeSpan(0, 0, 0, 400))
}
},
tempoMap: tempoMap);
}
private IEnumerable <Note> CreateNotes(string[] timesAndLengths,
SevenBitNumber noteNumber,
FourBitNumber channel,
TempoMap tempoMap)
{
var notes = ObjectMethods.CreateCollection(tempoMap, timesAndLengths);
foreach (var note in notes)
{
note.NoteNumber = noteNumber;
note.Channel = channel;
}
return(notes);
}
public void SplitByStep_StepEqualObjectsLength()
{
var tempoMap = TempoMap.Default;
var step = 1000L;
var inputObjects = CreateInputObjects(step);
var expectedObjects = inputObjects.Select(o => ObjectMethods.Clone(o));
var actualObjects = Splitter.SplitByStep(inputObjects, (MidiTimeSpan)step, tempoMap);
MidiAsserts.AreEqual(
expectedObjects.OfType <ITimedObject>(),
actualObjects.OfType <ITimedObject>(),
true,
0,
"Objects are invalid.");
}
public void SplitAtDistance_FullLengthRatio(LengthedObjectTarget from)
{
var tempoMap = TempoMap.Default;
var inputObjects = CreateInputObjects(1000);
var ratio = 1.0;
var expectedObjects = inputObjects.Select(o => ObjectMethods.Clone(o));
var actualObjects = Splitter.SplitAtDistance(inputObjects, ratio, TimeSpanType.Midi, from, tempoMap);
MidiAsserts.AreEqual(
expectedObjects.OfType <ITimedObject>(),
actualObjects.OfType <ITimedObject>(),
true,
0,
"Objects are invalid.");
}
public void SplitByPartsNumber_OnePart()
{
var tempoMap = TempoMap.Default;
var inputObjects = CreateInputObjects(100);
var partsNumber = 1;
var expectedObjects = inputObjects.Select(o => ObjectMethods.Clone(o));
var actualObjects = Splitter.SplitByPartsNumber(inputObjects, partsNumber, TimeSpanType.Midi, tempoMap);
MidiAsserts.AreEqual(
expectedObjects.OfType <ITimedObject>(),
actualObjects.OfType <ITimedObject>(),
true,
0,
"Objects are invalid.");
}
private void SplitByGrid_MultipleSteps(IEnumerable <TObject> inputObjects,
ITimeSpan gridStart,
IEnumerable <ITimeSpan> gridSteps,
Dictionary <TObject, IEnumerable <TimeAndLength> > expectedParts,
TempoMap tempoMap)
{
var expectedObjects = expectedParts
.SelectMany(p => p.Value.Select(tl => CloneAndChangeTimeAndLength(
p.Key,
TimeConverter.ConvertFrom(tl.Time, tempoMap),
LengthConverter.ConvertFrom(tl.Length, tl.Time, tempoMap))))
.ToArray();
var actualObjects = Splitter.SplitByGrid(inputObjects, new SteppedGrid(gridStart, gridSteps), tempoMap).ToArray();
ObjectMethods.AssertCollectionsAreEqual(expectedObjects, actualObjects);
}
