public void NormalizationFactorValue_CRUD_Positive()
{
// create
Place place = null;
NormalizationFactor normalizationFactor = null;
NormalizationFactorValue normalizationFactorValue = null;
Func <Task> asyncFunction = async() =>
{
place = await CreatePlace(Client);
normalizationFactor = await CreateNormalizationFactor(Client, place);
normalizationFactorValue = await CreateNormalizationFactorValue(Client, normalizationFactor);
};
asyncFunction.ShouldNotThrow();
normalizationFactorValue.Should().NotBeNull();
// read
IEnumerable <NormalizationFactorValue> normalizationFactorValues = null;
asyncFunction = async() => normalizationFactorValues = await Client.ReadNormalizationFactorValues(normalizationFactor.Id);
asyncFunction.ShouldNotThrow();
normalizationFactorValues.Should().NotBeNullOrEmpty();
normalizationFactorValues.Any(x => x.Timestamp == normalizationFactorValue.Timestamp && x.Value == normalizationFactorValue.Value).Should().BeTrue();
// update
var update = new UpdateNormalizationFactorValue(normalizationFactorValue)
{
Value = normalizationFactorValue.Value + "12345"
};
asyncFunction = async() => normalizationFactorValue = await Client.UpdateNormalizationFactorValue(normalizationFactor.Id, update);
asyncFunction.ShouldNotThrow();
normalizationFactorValue.Should().NotBeNull();
normalizationFactorValue.Timestamp.Should().Be(update.Timestamp);
normalizationFactorValue.Value.Should().Be(update.Value);
// delete
asyncFunction = async() => await Client.DeleteNormalizationFactorValue(normalizationFactor.Id, normalizationFactorValue.Timestamp);
asyncFunction.ShouldNotThrow();
// read
asyncFunction = async() => normalizationFactorValues = await Client.ReadNormalizationFactorValues(normalizationFactor.Id);
asyncFunction.ShouldNotThrow();
normalizationFactorValues.Should().NotBeNullOrEmpty();
// delete normalization factor and place
asyncFunction = async() =>
{
await Client.DeleteNormalizationFactor(normalizationFactor.Id);
await Client.DeletePlace(place.Id);
};
asyncFunction.ShouldNotThrow();
}
public override void SaveParamsForReport()
{
ReportGenerator g = ReportGenerator.Instance;
g.ClearReflModelInfo();
int arrayconst = 2;
List <string> ginfo = new List <string>();
if (HoldsigmaCB)
{
ginfo.Add("The reflectivity curve was fit with a single roughness parameter\n");
}
else
{
ginfo.Add(String.Format("The reflectivity curve was fit with {0} roughness parameters\n", BoxCountTB + 1));
arrayconst = 3;
}
ginfo.Add("Percent Error in Q: " + QSpreadTB.ToString() + "\n");
ginfo.Add("Normalization Factor: " + NormalizationFactor.ToString() + "\n");
ginfo.Add("Low Q Offset: " + LowQOffset.ToString() + "\n");
ginfo.Add("High Q Offset: " + HighQOffset.ToString() + "\n");
ginfo.Add("Superphase SLD: " + SubphaseSLDTB.ToString() + "\n");
ginfo.Add("Subphase SLD: " + SubphaseSLD.ToString() + "\n");
ginfo.Add("Wavelength: " + WavelengthTB.ToString() + "\n");
ginfo.Add("Chi Square for reflectivity fit: " + ChiSquare.ToString() + "\n");
ginfo.Add(string.Format("The subphase roughness was: {0:#.### E-0} " + (char)0x00B1 + " {1:#.### E-0}\n", SubRoughTB, CovarArray[0]));
for (int i = 0; i < BoxCountTB; i++)
{
ginfo.Add((i + 1).ToString());
ginfo.Add(LengthArray[i].ToString("#.### E-0") + " " + (char)0x00B1 + " " + CovarArray[arrayconst * i + 1].ToString("#.### E-0"));
if (!m_bUseSLD)
{
ginfo.Add(RhoArray[i].ToString("#.### E-0") + " " + (char)0x00B1 + " " + CovarArray[arrayconst * i + 2].ToString("#.### E-0"));
}
else
{
ginfo.Add((RhoArray[i] * SubphaseSLDTB).ToString("#.### E-0") + " " + (char)0x00B1 + " " + (CovarArray[arrayconst * i + 2] * SubphaseSLDTB).ToString("#.### E-0"));
}
if (HoldsigmaCB)
{
ginfo.Add(SigmaArray[i].ToString("#.### E-0") + " " + (char)0x00B1 + " " + CovarArray[0].ToString("#.### E-0"));
}
else
{
ginfo.Add(SigmaArray[i].ToString("#.### E-0") + " " + (char)0x00B1 + " " + CovarArray[arrayconst * i + 3].ToString("#.### E-0"));
}
}
g.SetReflModelInfo = ginfo;
}
public override string ErrorReport()
{
string output = string.Empty;
if (ImpNormCB)
{
output = (Environment.NewLine + "Normalization factor = " + NormalizationFactor.ToString("#.###") + " " +
(char)0x00B1 + " " + CovarArray[CovarArray.Length - 1].ToString("#.### E-0") + Environment.NewLine);
}
return(ErrorReport(output));
}
internal static async Task <NormalizationFactorValue> CreateNormalizationFactorValue(IWimdioApiClient client, NormalizationFactor nf)
{
var dateTime = DateTime.Now;
var rnd = new Random();
var normalizationFactorValue = new NormalizationFactorValue
{
Timestamp = dateTime.AddTicks(-(dateTime.Ticks % TimeSpan.TicksPerSecond)),
Value = rnd.Next(100000).ToString(),
};
return(await client.CreateNormalizationFactorValue(nf.Id, normalizationFactorValue));
}
public void NormalizationFactor_CRUD_Positive()
{
// create
Place place = null;
NormalizationFactor normalizationFactor = null;
Func <Task> asyncFunction = async() =>
{
place = await CreatePlace(Client);
normalizationFactor = await CreateNormalizationFactor(Client, place);
};
asyncFunction.ShouldNotThrow();
normalizationFactor.Should().NotBeNull();
// read
asyncFunction = async() => await Client.ReadNormalizationFactor(normalizationFactor.Id);
asyncFunction.ShouldNotThrow();
normalizationFactor.Should().NotBeNull();
// read list
IEnumerable <NormalizationFactor> normalizationFactors = null;
asyncFunction = async() => normalizationFactors = await Client.ReadNormalizationFactors(place.Id);
asyncFunction.ShouldNotThrow();
normalizationFactors.Should().NotBeNullOrEmpty();
normalizationFactors.Any(x => x.Id == normalizationFactor.Id);
// update
var updated = new UpdateNormalizationFactor(normalizationFactor)
{
Name = normalizationFactor.Name + " Updated",
Aggregation = AggregationType.Sum
};
asyncFunction = async() => normalizationFactor = await Client.UpdateNormalizationFactor(normalizationFactor.Id, updated);
asyncFunction.ShouldNotThrow();
normalizationFactor.Should().NotBeNull();
normalizationFactor.Name.Should().Be(updated.Name);
normalizationFactor.Aggregation.Should().Be(updated.Aggregation);
normalizationFactor.Description.Should().Be(updated.Description);
normalizationFactor.Operation.Should().Be(updated.Operation);
normalizationFactor.Unit.Should().Be(updated.Unit);
// delete
asyncFunction = async() => await Client.DeleteNormalizationFactor(normalizationFactor.Id);
asyncFunction.ShouldNotThrow();
// read list
asyncFunction = async() => normalizationFactors = await Client.ReadNormalizationFactors(place.Id);
asyncFunction.ShouldNotThrow();
normalizationFactors.Should().BeNullOrEmpty();
// delete place
asyncFunction = async() => await Client.DeletePlace(place.Id);
asyncFunction.ShouldNotThrow();
}
