/// <summary>
/// Parse list of values.
/// </summary>
/// <param name="valueListString">e.g. 1,3,4</param>
public static ValueWithCIsData Parse(string valueListString)
{
string[] bits = valueListString.Split(',');
ValueWithCIsData data = null;
if (bits.Length == 1)
{
data = new ValueWithCIsData { Value = double.Parse(bits[0]) };
}
else if (bits.Length == 3)
{
data = GetNullObject();
if (CanValueBeParsed(bits[0]))
{
// No data
}
else if (CanValueBeParsed(bits[1]))
{
// No CIs
data.Value = double.Parse(bits[0]);
}
else
{
data.Value = double.Parse(bits[0]);
data.LowerCI = double.Parse(bits[1]);
data.UpperCI = double.Parse(bits[2]);
}
}
return data;
}
public void TestFormatAndTruncateDataList()
{
var data = new ValueWithCIsData() { Value = Number };
DataProcessor().FormatAndTruncateList(new List<ValueWithCIsData>{data});
AssertValueTruncatedAsExpected(data);
Assert.AreEqual("1.11", data.ValueFormatted);
}
public override void FormatConfidenceIntervals(ValueWithCIsData data)
{
if (data != null)
{
data.UpperCIF = FormatNumber(data.UpperCI);
data.LowerCIF = FormatNumber(data.LowerCI);
}
}
public void TestFormatCIs()
{
var data = new ValueWithCIsData
{
UpperCI = 2.222222222,
LowerCI = Number
};
DataProcessor().FormatAndTruncate(data);
Assert.AreEqual("1.11", data.LowerCIF);
Assert.AreEqual("2.22", data.UpperCIF);
}
public void TestFormatConfidenceIntervals()
{
var formatter = NumericFormatterFactory.NewWithLimits(GetMetadata(1), null);
var data = new ValueWithCIsData
{
LowerCI = 1.1111,
UpperCI = 9.9999
};
formatter.FormatConfidenceIntervals(data);
Assert.AreEqual("1.1", data.LowerCIF);
Assert.AreEqual("10.0", data.UpperCIF);
}
public void TestFormatConfidenceIntervals_NullValues()
{
var formatter = NumericFormatterFactory.NewWithLimits(GetMetadata(1), null);
var data = new ValueWithCIsData
{
LowerCI = ValueData.NullValue,
UpperCI = ValueData.NullValue
};
formatter.FormatConfidenceIntervals(data);
Assert.AreEqual(NumericFormatter.NoValue, data.LowerCIF);
Assert.AreEqual(NumericFormatter.NoValue, data.UpperCIF);
}
public void TestGetBaseData()
{
ValueWithCIsData data = new ValueWithCIsData
{
Value = 1,
LowerCI = 2,
UpperCI = 3,
Count = 4
};
ValueWithCIsData copy = data.GetValueWithCIsData();
Assert.AreEqual(data.Value, copy.Value);
Assert.AreEqual(data.Count, copy.Count);
Assert.AreEqual(data.LowerCI, copy.LowerCI);
Assert.AreEqual(data.UpperCI, copy.UpperCI);
}
private Significance GetSignificance(ValueWithCIsData data, ValueWithCIsData comparator)
{
if (CanComparisonGoAhead(data, comparator) == false ||
data.AreCIsValid == false ||
comparator.AreCIsValid == false)
{
return Significance.None;
}
if (DoCIsOverlap(comparator, data))
{
return Significance.Same;
}
if (data.Value < comparator.Value)
{
return AdjustForPolarity(Significance.Worse);
}
return AdjustForPolarity(Significance.Better);
}
public void TestTruncateUpperCI()
{
var data = new ValueWithCIsData { UpperCI = Number };
TruncateData(data);
Assert.AreEqual(TruncatedNumber, data.UpperCI);
}
public abstract void FormatConfidenceIntervals(ValueWithCIsData data);
private static bool DoCIsOverlap(ValueWithCIsData data1, ValueWithCIsData data2)
{
return data1.Value < data2.Value ? data2.LowerCI <= data1.UpperCI : data1.LowerCI <= data2.UpperCI;
}
public Significance Compare(ValueWithCIsData data, ValueWithCIsData comparator, IndicatorMetadata metadata)
{
return GetSignificance(data, comparator);
}
protected virtual bool CanComparisonGoAhead(ValueWithCIsData data, ValueWithCIsData comparator)
{
return IsPolarityValid() && IsDataValid(data) && IsDataValid(comparator);
}
protected bool CanComparisonGoAhead(ValueWithCIsData data)
{
return IsPolarityValid() && IsDataValid(data);
}
protected static void SetValueWithCIsDataDefaults(ValueWithCIsData data)
{
data.Value = NullValue;
data.LowerCI = NullValue;
data.UpperCI = NullValue;
}
public static ValueWithCIsData GetNullObject()
{
ValueWithCIsData data = new ValueWithCIsData();
SetValueWithCIsDataDefaults(data);
return data;
}
private static void AssertValueTruncatedAsExpected(ValueWithCIsData data)
{
Assert.AreEqual(1.1111, data.Value);
}
protected bool IsDataValid(ValueWithCIsData data)
{
return data != null && data.IsValueValid;
}
public void TestTruncateDataList()
{
var data = new ValueWithCIsData { Value = Number };
DataProcessor().TruncateList(new List<ValueWithCIsData> { data });
AssertValueTruncatedAsExpected(data);
}
public void TestTruncateData()
{
var data = new ValueWithCIsData { Value = Number };
DataProcessor().Truncate(data);
AssertValueTruncatedAsExpected(data);
}
private static void TruncateData(ValueWithCIsData data)
{
var processor = new ValueWithCIsDataProcessor(new Moq.Mock<DefaultFormatter>().Object);
processor.FormatAndTruncate(data);
}
