public void NegativeTestStartCount()
{
var getRangeTest1 = new GetRange();
var resultOfAmount = getRangeTest1.StartCount(5, 3).Count();
Assert.False(5.Equals(resultOfAmount));
}
public SequenceConstruction <KeyT> GetRange <KeyT>(SequenceConstruction <KeyT> sequenceConstruction, IRangeBoundary <KeyT> range)
{
long minAddr = 0L;
long maxAddr = (sequenceConstruction.Index.KeyCount - 1);
long loBound = 0;
long hiBound = 0;
if (range.GetType() == typeof(IntervalOf <KeyT>))
{
var newRange = (IntervalOf <KeyT>)range;
//TODO support other lookup semantics
//TODO add error handling missing keys here
loBound = sequenceConstruction.Index.Lookup(newRange.Start, LookupSemantics.Exact).Value;
hiBound = sequenceConstruction.Index.Lookup(newRange.End, LookupSemantics.Exact).Value;
}
//TODO add checks for missing keys
if (hiBound > loBound)
{
var newIndex = new LinearRangeIndex <KeyT>(sequenceConstruction.Index, loBound, hiBound);
IVecConstructionCmd newVectorContr = new GetRange(sequenceConstruction.VectorConstruction, new IntervalOf <Int64>(hiBound, loBound, BoundaryBehavior.Inclusive));
return(new SequenceConstruction <KeyT>(newIndex, newVectorContr));
}
else
{
//TODO reversed range handling
}
//TODO
return(null);
}
public void PositiveTestStartCount()
{
//Arrange
var getRangeTest = new GetRange();
//Act
var resultOfAmount = getRangeTest.StartCount(1, 8).Count();
//Assert
Assert.Equal(8, resultOfAmount);
}
public void CheckAmountOfStartCountExpected8Elements()
{
//Arrange
var con = new GetRange();
//Act
//Assert
}
public SequenceConstruction <KeyT> GetAddressRange <KeyT>(SequenceConstruction <KeyT> indexConstruction, IRangeBoundary <long> range)
{
//TODO come up with better type conversions here
if (range.GetType() == typeof(IntervalOf <long>))
{
var newRange = (IntervalOf <long>)range;
var newVectorConstr = new GetRange(indexConstruction.VectorConstruction, new IntervalOf <long>(newRange.Start, newRange.End, BoundaryBehavior.Inclusive));
var newIndex = new LinearRangeIndex <KeyT>(indexConstruction.Index, newRange.Start, newRange.End);
return(new SequenceConstruction <KeyT>(newIndex, newVectorConstr));
}
return(null);
}
public void PositiveSumOfAllElementsEventsArgs()
{
//Arrange
var getRangeTest2 = new GetRange();
SumOfAllElementsEventArgs args = null;
getRangeTest2.SumOfAllElementsEA += (s, e) => { args = e; };
//Act
getRangeTest2.StartCount(3, 8).ToList();
//Assert
Assert.Equal(52, args.SumOfAllElements);
}
public void Should_serialize_deserialize_object()
{
var settings = new AvroSerializerSettings
{
GenerateDeserializer = true,
GenerateSerializer = true,
Resolver = new AvroPublicMemberContractResolver(false),
MaxItemsInSchemaTree = 40,
UseCache = true
};
//var avroSerializer2 = AvroSerializer.Create<ChannelRangeInfo>(settings);
var avroSerializer = AvroSerializer.Create <GetRange>(settings);
var message = new GetRange
{
ChannelRanges = new List <ChannelRangeInfo>
{
new ChannelRangeInfo {
ChannelId = new List <long> {
1, 2, 3
}, Interval = new Etp.v12.Datatypes.Object.IndexInterval {
DepthDatum = "datum", EndIndex = new Etp.v12.Datatypes.IndexValue {
Item = 0.0
}, StartIndex = new Etp.v12.Datatypes.IndexValue {
Item = 0.0
}, Uom = "Uom"
}
}
},
RequestUuid = new Etp.v12.Datatypes.Uuid
{
Value = new byte[16]
}
};
using (var buffer = new MemoryStream())
{
avroSerializer.Serialize(buffer, message);
buffer.Seek(0, SeekOrigin.Begin);
var result = avroSerializer.Deserialize(buffer);
Console.WriteLine(result);
}
}
/// <summary>
/// Creates an array of frames from a string expression. The expression must be similar to the following format:
/// "0,3,7-11,2,5"
/// Whitespace is permitted, and commas are optional.
/// <param name="input">A string formatted as above, describing the frames to generate.</param>
/// </summary>
public static int[] ParseFrames(string input)
{
// Make sure the pattern matches, and alert the user if it doesn't
var parse = SyntaxCheck.Match(input);
if (!parse.Success)
{
throw new Exception(string.Format("Invalid format: {0}", input));
}
// Get all numbers/ranges in the input string.
var frames = new List <int>();
foreach (Match match in GetMatches.Matches(input))
{
var range = GetRange.Match(match.Value);
if (range.Success)
{
int from = int.Parse(range.Groups[1].Value);
int to = int.Parse(range.Groups[2].Value);
// Support ascending and descending ranges
if (from < to)
{
while (from <= to)
{
frames.Add(from++);
}
}
else
{
while (from >= to)
{
frames.Add(from--);
}
}
}
else
{
frames.Add(int.Parse(match.Value));
}
}
return(frames.ToArray());
}
