public void TestDurationToMillis()
{
Assert.Equal(0, MutableViewData.ToMillis(Duration.Create(0, 0)));
Assert.Equal(987, MutableViewData.ToMillis(Duration.Create(0, 987000000)));
Assert.Equal(3456, MutableViewData.ToMillis(Duration.Create(3, 456000000)));
Assert.Equal(-1, MutableViewData.ToMillis(Duration.Create(0, -1000000)));
Assert.Equal(-1000, MutableViewData.ToMillis(Duration.Create(-1, 0)));
Assert.Equal(-3456, MutableViewData.ToMillis(Duration.Create(-3, -456000000)));
}
internal static IAggregationData CreateAggregationData(IAggregation aggregation, IMeasure measure, params double[] values)
{
var mutableAggregation = MutableViewData.CreateMutableAggregation(aggregation);
foreach (var value in values)
{
mutableAggregation.Add(value);
}
return(MutableViewData.CreateAggregationData(mutableAggregation, measure));
}
public void CreateAggregationData()
{
IBucketBoundaries bucketBoundaries = BucketBoundaries.Create(new List <double>()
{
-1.0, 0.0, 1.0
});
List <MutableAggregation> mutableAggregations =
new List <MutableAggregation>()
{
MutableCount.Create(),
MutableMean.Create(),
MutableDistribution.Create(bucketBoundaries)
};
List <IAggregationData> aggregates = new List <IAggregationData>
{
MutableViewData.CreateAggregationData(MutableSum.Create(), MEASURE_DOUBLE),
MutableViewData.CreateAggregationData(MutableSum.Create(), MEASURE_LONG),
MutableViewData.CreateAggregationData(MutableLastValue.Create(), MEASURE_DOUBLE),
MutableViewData.CreateAggregationData(MutableLastValue.Create(), MEASURE_LONG)
};
foreach (MutableAggregation mutableAggregation in mutableAggregations)
{
aggregates.Add(MutableViewData.CreateAggregationData(mutableAggregation, MEASURE_DOUBLE));
}
List <IAggregationData> expected = new List <IAggregationData>()
{
SumDataDouble.Create(0),
SumDataLong.Create(0),
LastValueDataDouble.Create(double.NaN),
LastValueDataLong.Create(0),
CountData.Create(0),
MeanData.Create(0, 0, double.MaxValue, double.MinValue),
DistributionData.Create(
0,
0,
double.PositiveInfinity,
double.NegativeInfinity,
0,
new List <long>()
{
0L, 0L, 0L, 0L
})
};
Assert.Equal(expected, aggregates);
}
public void TestGetTagValues()
{
List <ITagKey> columns = new List <ITagKey>()
{
CALLER, METHOD, ORIGINATOR
};
IDictionary <ITagKey, ITagValue> tags = new Dictionary <ITagKey, ITagValue>()
{
{ CALLER, CALLER_V }, { METHOD, METHOD_V }
};
Assert.Equal(new List <ITagValue>()
{
CALLER_V, METHOD_V, MutableViewData.UNKNOWN_TAG_VALUE
},
MutableViewData.GetTagValues(tags, columns));
}
public void TestGetTagValues()
{
IReadOnlyList <TagKey> columns = new List <TagKey>()
{
CALLER, METHOD, ORIGINATOR
};
IDictionary <TagKey, TagValue> tags = new Dictionary <TagKey, TagValue>()
{
{ CALLER, CALLER_V }, { METHOD, METHOD_V }
};
Assert.Equal(new List <TagValue>()
{
CALLER_V, METHOD_V, MutableViewData.UnknownTagValue
},
MutableViewData.GetTagValues(tags, columns));
}
public void CreateMutableAggregation()
{
var bucketBoundaries = BucketBoundaries.Create(new List <double>()
{
-1.0, 0.0, 1.0
});
Assert.InRange(((MutableSum)MutableViewData.CreateMutableAggregation(Sum.Create())).Sum, 0.0 - EPSILON, 0.0 + EPSILON);
Assert.Equal(0, ((MutableCount)MutableViewData.CreateMutableAggregation(Count.Create())).Count);
Assert.InRange(((MutableMean)MutableViewData.CreateMutableAggregation(Mean.Create())).Mean, 0.0 - EPSILON, 0.0 + EPSILON);
Assert.True(Double.IsNaN(((MutableLastValue)MutableViewData.CreateMutableAggregation(LastValue.Create())).LastValue));
var mutableDistribution =
(MutableDistribution)MutableViewData.CreateMutableAggregation(Distribution.Create(bucketBoundaries));
Assert.Equal(double.PositiveInfinity, mutableDistribution.Min);
Assert.Equal(double.NegativeInfinity, mutableDistribution.Max);
Assert.InRange(mutableDistribution.SumOfSquaredDeviations, 0.0 - EPSILON, 0.0 + EPSILON);
Assert.Equal(new long[4], mutableDistribution.BucketCounts);
}
