public void TestCompletenessReportGenerationSomeCustomer()
{
var files = Directory.GetFiles("Energiemenge/completeness", "somecustomer*.json");
Assert.AreEqual(5, files.Count()); // this is just to make sure the files haven't moved
foreach (string boFile in files)
{
JObject json;
using (StreamReader r = new StreamReader(boFile))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
Energiemenge em = (Energiemenge)BoMapper.MapObject((JObject)json["input"], LenientParsing.Strict);
CompletenessReport cr;
if (boFile.EndsWith("somecustomer1.json"))
{
cr = em.GetCompletenessReport();
Assert.AreEqual((decimal)0.9601, Math.Round(cr.Coverage.Value, 4));
Assert.AreEqual("4-5-6-7", cr.Obiskennzahl);
Assert.AreEqual(Wertermittlungsverfahren.MESSUNG, cr.wertermittlungsverfahren);
Assert.AreEqual(Mengeneinheit.KWH, cr.Einheit);
Assert.AreEqual("DEXXX", cr.LokationsId);
//Assert.AreEqual(15, cr.values[0].wert);
//Assert.AreEqual(TestEnergiemengeExtension.GERMAN_APRIL_2018.Start, cr.values[0].startdatum);
string resultString = JsonConvert.SerializeObject(cr, new StringEnumConverter());
Assert.IsNotNull(cr.Gaps);
Assert.AreEqual(1, cr.Gaps.Count);
Assert.AreEqual(new DateTime(2018, 4, 1, 1, 45, 0, DateTimeKind.Utc), cr.Gaps.First().Startdatum);
Assert.AreEqual(new DateTime(2018, 4, 2, 6, 30, 0, DateTimeKind.Utc), cr.Gaps.First().Enddatum);
}
else if (boFile.EndsWith("somecustomer2.json"))
{
foreach (var combi in em.GetWevObisMeCombinations())
{
cr = em.GetCompletenessReport(TestEnergiemengeExtension.GERMAN_APRIL_2018, combi.Item1, combi.Item2, combi.Item3);
string resultString = JsonConvert.SerializeObject(cr, new StringEnumConverter());
CompletenessReport cr2 = em.GetCompletenessReport(new CompletenessReport.CompletenessReportConfiguration
{
Einheit = combi.Item3,
Obis = combi.Item2,
Wertermittlungsverfahren = combi.Item1,
ReferenceTimeFrame = new BO4E.COM.Zeitraum
{
Startdatum = TestEnergiemengeExtension.GERMAN_APRIL_2018.Start,
Enddatum = TestEnergiemengeExtension.GERMAN_APRIL_2018.End
}
});
//Assert.AreEqual(cr, cr2, "calling report with configuration instead of loose parameters doesn't work.");
}
}
else if (boFile.EndsWith("somecustomer3.json"))
{
}
else if (boFile.EndsWith("somecustomer4.json"))
{
}
}
}
public void TestCompletenessReportGenerationSmard()
{
MiniProfiler profiler = MiniProfiler.StartNew(nameof(TestCompletenessReportGenerationSmard));
IList <CompletenessReport> crlist = new List <CompletenessReport>();
foreach (string boFile in Directory.GetFiles("Energiemenge/completeness", "50hz_prognose*.json"))
{
using (MiniProfiler.Current.Step($"Processing file {boFile}"))
{
JObject json;
using (StreamReader r = new StreamReader(boFile))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
Energiemenge em = (Energiemenge)BoMapper.MapObject(json, LenientParsing.Strict);
CompletenessReport cr = em.GetCompletenessReport();
crlist.Add(cr);
if (boFile.Contains("onshore.json"))
{
Assert.IsNotNull(cr.UserProperties);
Assert.AreEqual <string>("yippi yippi yeah", cr.UserProperties["meineUp0"].Value <string>());
Assert.AreEqual <string>("krawall und remmidemmi", cr.UserProperties["meineUp1"].Value <string>());
}
}
}
string resultString = JsonConvert.SerializeObject(crlist, new StringEnumConverter());
profiler.Stop();
System.Diagnostics.Debug.WriteLine($"Profiler results: {profiler.RenderPlainText()}");
}
public void TestRounding()
{
string boFile = Directory.GetFiles("Energiemenge/completeness", "gas_januar_2018.json").First();
JObject json;
using (StreamReader r = new StreamReader(boFile))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
Energiemenge em = (Energiemenge)BoMapper.MapObject(JObject.FromObject(json["input"]), LenientParsing.Strict);
CompletenessReport cr = em.GetCompletenessReport(new TimeRange()
{
Start = new DateTime(2017, 12, 31, 23, 0, 0, 0, DateTimeKind.Utc),
End = new DateTime(2018, 1, 31, 23, 0, 0, 0, DateTimeKind.Utc)
});
Assert.AreEqual(1.0M, cr.Coverage.Value);
Assert.AreEqual(0, cr.Gaps.Count());
var dailies = em.GetDailyCompletenessReports(new TimeRange()
{
Start = new DateTime(2017, 12, 31, 23, 0, 0, 0, DateTimeKind.Utc),
End = new DateTime(2018, 1, 2, 23, 0, 0, 0, DateTimeKind.Utc)
});
foreach (var crDaily in dailies)
{
Assert.AreEqual(1.0M, crDaily.Value.Coverage.Value, $"error in slice {crDaily.Key}");
}
Assert.AreEqual(1.0M, cr.Coverage.Value);
}
public override void Write(Utf8JsonWriter writer, BusinessObject value, JsonSerializerOptions options)
{
var boTypeString = value.GetBoTyp();
#pragma warning disable CS0618 // Type or member is obsolete
var boType = BoMapper.GetTypeForBoName(boTypeString);
#pragma warning restore CS0618 // Type or member is obsolete
System.Text.Json.JsonSerializer.Serialize(writer, value, boType, options);
}
public void TestBoNames()
{
HashSet <string> testResult = BoMapper.GetValidBoNames();
Assert.IsTrue(testResult.Contains("Messlokation"));
Assert.IsTrue(testResult.Contains("Energiemenge"));
Assert.IsFalse(testResult.Contains("Verbrauch"), "No COM");
Assert.IsFalse(testResult.Contains("CompletenessReport")); // has moved to extensions
Assert.IsFalse(testResult.Contains("Mengeneinheit"), "No enums");
}
/// <summary>
/// Get name of business object with correct upper/lower case (the host value)
/// </summary>
/// <returns>business object name or null iff there is no such object</returns>
public string GetBoName()
{
foreach (string boName in BoMapper.GetValidBoNames())
{
if (boName.ToUpper().Equals(this.Host.ToUpper()))
{
return(boName);
}
}
return(null);
}
/// <summary>
/// Get name of business object with correct upper/lower case (the host value)
/// </summary>
/// <returns>business object name or null iff there is no such object</returns>
public string GetBoName()
{
#pragma warning disable CS0618 // Type or member is obsolete
foreach (string boName in BoMapper.GetValidBoNames())
#pragma warning restore CS0618 // Type or member is obsolete
{
if (boName.ToUpper().Equals(this.Host.ToUpper()))
{
return(boName);
}
}
return(null);
}
public override BusinessObject Read(ref Utf8JsonReader reader, Type typeToConvert,
JsonSerializerOptions options)
{
if (reader.TokenType == JsonTokenType.Null)
{
return(null);
}
if (typeToConvert.IsAbstract)
{
var jdoc = JsonDocument.ParseValue(ref reader);
if (!jdoc.RootElement.TryGetProperty("BoTyp", out var boTypeProp))
{
boTypeProp = jdoc.RootElement.GetProperty("boTyp");
}
var boTypeString = boTypeProp.GetString();
#pragma warning disable CS0618 // Type or member is obsolete
var boType = BoMapper.GetTypeForBoName(boTypeString);
#pragma warning restore CS0618 // Type or member is obsolete
if (boType == null)
{
foreach (var assembley in AppDomain.CurrentDomain.GetAssemblies())
{
try
{
boType = assembley.GetTypes().FirstOrDefault(x =>
string.Equals(x.Name, boTypeString, StringComparison.CurrentCultureIgnoreCase));
}
catch (ReflectionTypeLoadException)
{
continue;
}
if (boType != null)
{
break;
}
}
if (boType == null)
{
throw new NotImplementedException(
$"The type '{boTypeString}' does not exist in the BO4E standard.");
}
}
return(System.Text.Json.JsonSerializer.Deserialize(jdoc.RootElement.GetRawText(), boType, options)
as BusinessObject);
}
return(null);
}
public void TestDailyCompleteness()
{
foreach (string boFile in Directory.GetFiles("Energiemenge/completeness/", "50hz_prognose*.json"))
{
using (MiniProfiler.Current.Step($"Processing file {boFile}"))
{
JObject json;
using (StreamReader r = new StreamReader(boFile))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
Energiemenge em = BoMapper.MapObject <Energiemenge>(json, LenientParsing.Strict);
var result = em.GetDailyCompletenessReports(CHRISTMAS_2018);
Assert.AreEqual(8, result.Count);
break; // one test is enough. the rest is covered by the individual completeness report tests.
}
}
}
public void TestBoEdiReplacement()
{
string[] files = Directory.GetFiles($"BoEdiMapper/", "*.json");
foreach (string file in files)
{
JObject json;
using (StreamReader r = new StreamReader(file))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
Assert.IsNotNull(json["input"], $"You have to specify an 'input' in test file {file}");
Assert.IsNotNull(json["expectedResult"], $"You have to specify an 'expectedOutput' in test file {file}");
BusinessObject bo;
try
{
bo = JsonConvert.DeserializeObject <BusinessObject>(json["input"].ToString());
}
catch (ArgumentException)
{
bo = BoMapper.MapObject(json["input"]["boTyp"].ToString(), (JObject)json["input"]);
}
JObject result = BoEdiMapper.ReplaceWithEdiValues(bo);
//JObject result = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeObject(, new StringEnumConverter()));
var jdp = new JsonDiffPatch();
var left = JsonHelper.RemoveEmptyChildren(json["expectedResult"]);
var right = JsonHelper.RemoveEmptyChildren(result);
var patch = jdp.Diff(left, right);
string additionalMessage = string.Empty;
if (patch != null)
{
additionalMessage = $";\r\n Diff: { patch.ToString()}";
}
try
{
Assert.IsNull(patch, additionalMessage);
}
catch (AssertFailedException) when(patch != null && additionalMessage.Contains("HGAS") && additionalMessage.Contains("H_GAS"))
{
}
}
}
public void TestBoNameTyping()
{
Assert.AreEqual(typeof(Benachrichtigung), BoMapper.GetTypeForBoName("Benachrichtigung"));
Assert.AreEqual(typeof(Benachrichtigung), BoMapper.GetTypeForBoName("bEnAcHriCHTIGuNg"));
Assert.ThrowsException <ArgumentNullException>(() => BoMapper.GetTypeForBoName(null), "null as argument must result in a ArgumentNullException");
/*
* bool argumentExceptionThrown = false;
* try
* {
* BoMapper.GetTypeForBoName("dei mudder ihr business object");
* }
* catch (ArgumentException)
* {
* argumentExceptionThrown = true;
* }
* Assert.IsTrue(argumentExceptionThrown, "invalid argument must result in a ArgumentException");
*/
Assert.IsNull(BoMapper.GetTypeForBoName("dei mudder ihr business object"), "invalid business object names must result in null");
}
internal void TestMonthlySlices(bool testFirstOnly = true, bool useParallelExecution = false)
{
foreach (string boFile in Directory.GetFiles("Energiemenge/completeness", "50hz_prognose*.json"))
{
using (MiniProfiler.Current.Step($"Processing file {boFile} with parallel={useParallelExecution}"))
{
JObject json;
using (StreamReader r = new StreamReader(boFile))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
Energiemenge em = BoMapper.MapObject <Energiemenge>(json, LenientParsing.Strict);
var result = em.GetMonthlyCompletenessReports(GERMAN_YEAR_2018, useParallelExecution: useParallelExecution);
Assert.AreEqual(12, result.Count); // don't care about values of coverage, just the start/end and count of reports generated.
if (testFirstOnly)
{
break; // one test is enough. the rest is covered by the individual completeness report tests
}
}
}
}
public void TestEnergiemengeObjects()
{
foreach (string boFile in Directory.GetFiles("Energiemenge/", "*.json"))
{
JObject json;
using (StreamReader r = new StreamReader(boFile))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
JObject assertions = (JObject)json["assertions"];
if (assertions == null)
{
continue;
}
// Assert.IsNotNull(assertions, $"Your test file {boFile} is broken. It has no 'assertions' key on root level.");
JObject bo = (JObject)json["input"];
Assert.IsNotNull(bo, $"Your test file {boFile} is broken. It has no 'input' key on root level.");
Energiemenge em;
try
{
if (boFile.Contains("wintertime2018.json"))
{
em = BoMapper.MapObject <Energiemenge>(bo, LenientParsing.DateTime);
}
else
{
em = BoMapper.MapObject <Energiemenge>(bo);
}
}
catch (JsonSerializationException e)
{
Assert.IsTrue(false, $"Your test BO is broken: {e.Message}");
return;
}
if (json.TryGetValue("fixSapCdsBug", out var fixSapCdsRaw))
{
bool fixit = fixSapCdsRaw.Value <bool>();
if (fixit)
{
em.FixSapCDSBug();
}
}
foreach (JProperty assertion in assertions.Properties())
{
switch (assertion.Name)
{
case "totalConsumption":
Assert.AreEqual(assertion.Value, em.GetTotalConsumption().Item1);
break;
case "totalConsumption-2018":
Assert.AreEqual(assertion.Value, em.GetConsumption(new TimeRange(new DateTime(2018, 01, 01), new DateTime(2019, 01, 01))).Item1);
break;
case "load-kW":
foreach (JProperty dateAssertion in ((JObject)assertions["load-kW"]).Properties())
{
if (DateTime.TryParseExact(dateAssertion.Name, "yyyyMMddHHmmss", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out DateTime dt))
{
Assert.AreEqual(dateAssertion.Value, em.GetLoad(Mengeneinheit.KW, dt.ToUniversalTime()));
}
else
{
Assert.IsTrue(false, "Please specify the load dates in the testfiles as yyyyMMddHHmmss");
}
}
break;
case "average":
try
{
Assert.AreEqual(Math.Round((decimal)assertion.Value, 12), Math.Round((decimal)em.GetAverage().Item1, 12));
}
catch (ArgumentException)
{
Assert.IsTrue(assertion.Value.Type.ToString() == "Null"); // a null value node
}
break;
case "isContinuous":
Assert.AreEqual(assertion.Value, em.IsContinuous(), $"{assertion.Name}: {boFile}");
break;
case "isEvenlySpaced":
Assert.AreEqual(assertion.Value, em.IsEvenlySpaced(), $"{assertion.Name}: {boFile}");
break;
case "isEvenlySpacedWithinDefinition":
Assert.AreEqual(assertion.Value, em.IsEvenlySpaced(true), $"{assertion.Name}: {boFile}");
break;
case "missingTimeRangeCount":
Assert.AreEqual(assertion.Value, em.GetMissingTimeRanges().Count, $"{assertion.Name}: {boFile}");
break;
case "coverage201804":
Assert.AreEqual(assertion.Value, Math.Round(em.GetCoverage(GERMAN_APRIL_2018), 4));
break;
case "coverage201803":
Assert.AreEqual(assertion.Value, Math.Round(em.GetCoverage(GERMAN_MARCH_2018), 8));
break;
case "coverage2018032425":
Assert.AreEqual(assertion.Value, Math.Round(em.GetCoverage(march2425), 4));
break;
case "coverage201804-KWHPROGNOSE1234":
Assert.AreEqual(assertion.Value, Math.Round(em.GetCoverage(GERMAN_APRIL_2018, Wertermittlungsverfahren.PROGNOSE, "1-2-3-4", Mengeneinheit.KWH), 4), $"{assertion.Name}: {boFile}");
break;
case "coverage201804-KWHMESSUNG5678":
Assert.AreEqual(assertion.Value, Math.Round(em.GetCoverage(GERMAN_APRIL_2018, Wertermittlungsverfahren.MESSUNG, "5-6-7-8", Mengeneinheit.KWH), 4), $"{assertion.Name}: {boFile}");
break;
case "jointCoverage":
Assert.AreEqual(assertion.Value, Math.Round(em.GetJointCoverage(GERMAN_APRIL_2018), 4), $"{assertion.Name}: {boFile}");
break;
case "isPure":
Assert.AreEqual <bool>((bool)assertion.Value, em.IsPure(), boFile);
if (!(bool)assertion.Value)
{
var pureEms = em.SplitInPureGroups();
var emptyEm = em.DeepClone();
emptyEm.Energieverbrauch = null;
Assert.AreEqual(em.Energieverbrauch.Count, pureEms.Select(x => x.Energieverbrauch.Count).Sum());
foreach (var pureEm in pureEms)
{
Assert.IsTrue(pureEm.IsPure());
var emptyPureEm = pureEm.DeepClone();
emptyPureEm.Energieverbrauch = null;
Assert.AreEqual(emptyEm, emptyPureEm);
}
}
break;
case "isPureUserProperties":
Assert.AreEqual <bool>((bool)assertion.Value, em.IsPure(true), boFile);
break;
default:
Assert.IsTrue(false, $"Unknown assertion type {assertion.Name} in {boFile}");
break;
}
}
// test normalising for all Energiemenge objects
if (em.IsPure() && em.IsExtensive() && em.GetTotalConsumption().Item1 != 0.0M)
{
decimal targetValue = 1000.0M;
Energiemenge emNormalised = em.Normalise(targetValue);
Assert.AreEqual(Math.Round(targetValue, 12), Math.Round(emNormalised.GetTotalConsumption().Item1, 12));
}
if (em.IsIntensive()) // test this once for one object. that's enough
{
Assert.ThrowsException <ArgumentException>(() => em.GetTotalConsumption(), "It must not be allowed to add up intensive units.");
}
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
if (objectType.IsAbstract)
{
JObject jo = JObject.Load(reader);
Type boType;
if (serializer.TypeNameHandling.HasFlag(TypeNameHandling.Objects) && jo.TryGetValue("$type", out JToken typeToken))
{
boType = BusinessObjectSerializationBinder.BusinessObjectAndCOMTypes.SingleOrDefault(t => typeToken.Value <string>().ToUpper().StartsWith(t.FullName.ToUpper()));
}
else if (!jo.ContainsKey("boTyp"))
{
throw new ArgumentException("If deserializing into an abstract BusinessObject the key \"boTyp\" has to be set. But it wasn't.");
}
else
{
#pragma warning disable CS0618 // Type or member is obsolete
boType = BoMapper.GetTypeForBoName(jo["boTyp"].Value <string>()); // ToDo: catch exception if boTyp is not set and throw exception with descriptive error message
#pragma warning restore CS0618 // Type or member is obsolete
}
if (boType == null)
{
foreach (var assembley in AppDomain.CurrentDomain.GetAssemblies())
{
try
{
boType = assembley.GetTypes().FirstOrDefault(x => x.Name.ToUpper() == jo["boTyp"].Value <string>().ToUpper());
}
catch (ReflectionTypeLoadException)
{
continue;
}
if (boType != null)
{
break;
}
}
if (boType == null)
{
throw new NotImplementedException($"The type '{jo["boTyp"].Value<string>()}' does not exist in the BO4E standard.");
}
}
var deserializationMethod = serializer.GetType() // https://stackoverflow.com/a/5218492/10009545
.GetMethods()
.Where(m => m.Name == nameof(serializer.Deserialize))
.Select(m => new
{
Method = m,
Params = m.GetParameters(),
Args = m.GetGenericArguments()
})
.Where(x => x.Params.Length == 1 &&
x.Args.Length == 1)
.Select(x => x.Method)
.First()
.GetGenericMethodDefinition()
.MakeGenericMethod(new Type[] { boType });
try
{
return(deserializationMethod.Invoke(serializer, new object[] { jo.CreateReader() }));
}
catch (TargetInvocationException tie) when(tie.InnerException != null)
{
throw tie.InnerException; // to hide the reflection to the outside.
}
}
else
{
serializer.ContractResolver.ResolveContract(objectType).Converter = null;
return(serializer.Deserialize(JObject.Load(reader).CreateReader(), objectType));
}
}
/// <summary>
/// Apply the operations from the configuration provided in the constructor to <paramref name="jobject"/>.
/// </summary>
/// <param name="jobject"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T ApplyOperations <T>(JObject jobject) where T : BusinessObject
{
var bo = BoMapper.MapObject(jobject, LenientParsing.MOST_LENIENT);
return(ApplyOperations <T>(bo));
}
/// <summary>
/// <see cref="GetExpandablePropertyNames(Type)"/>
/// </summary>
/// <param name="boTypeName">name of the business object as string</param>
/// <returns><see cref="GetExpandablePropertyNames(Type)"/></returns>
public static Dictionary <string, Type> GetExpandableFieldNames(string boTypeName)
{
Type clazz = Assembly.GetExecutingAssembly().GetType(BoMapper.packagePrefix + "." + boTypeName);
if (clazz == null)
{
throw new ArgumentException($"{boTypeName} is not a valid Business Object name. Use one of the following: {string.Join("\n -", BoMapper.GetValidBoNames())}");
}
return(GetExpandablePropertyNames(clazz));
}
public void TestBoMapping()
{
string[] files = Directory.GetFiles($"BoMapperTests/", "*.json");
foreach (string file in files)
{
JObject json;
using (StreamReader r = new StreamReader(file))
{
string jsonString = r.ReadToEnd();
json = JsonConvert.DeserializeObject <JObject>(jsonString);
}
Assert.IsNotNull(json["objectName"], $"You have to specify the object name in test file {file}");
LenientParsing lenients = LenientParsing.Strict; // default
if (json["lenientDateTime"] != null && (bool)json["lenientDateTime"])
{
lenients |= LenientParsing.DateTime;
}
if (json["lenientEnumList"] != null && (bool)json["lenientEnumList"])
{
lenients |= LenientParsing.EnumList;
}
if (json["lenientBo4eUri"] != null && (bool)json["lenientBo4eUri"])
{
lenients |= LenientParsing.Bo4eUri;
}
if (json["lenientStringToInt"] != null && (bool)json["lenientStringToInt"])
{
lenients |= LenientParsing.StringToInt;
}
BusinessObject bo;
try
{
bo = JsonConvert.DeserializeObject <BusinessObject>(json["input"].ToString(), lenients.GetJsonSerializerSettings());
}
catch (Exception e) when(e is ArgumentException || e is JsonSerializationException)
{
bo = BoMapper.MapObject(json["objectName"].ToString(), (JObject)json["input"], lenients);
}
string regularOutputString = JsonConvert.SerializeObject(bo, new StringEnumConverter());
if (bo.GetType() == typeof(Rechnung))
{
continue; // todo: fix this!
}
/*if (json["input"]["boTyp"] != null)
* {
* //BusinessObject bo2 = BoMapper.MapObject((JObject)json["input"], lenients);
* BusinessObject bo2 = JsonConvert.DeserializeObject<BusinessObject>(json["input"].ToString(), BoMapper.GetJsonSerializerSettings(lenients));
* //string regularOutputString2 = JsonConvert.SerializeObject(bo2, new StringEnumConverter());
* Assert.AreEqual(bo, bo2);
* switch (json["input"]["boTyp"].ToString().ToLower())
* {
* case "energiemenge":
* //Assert.AreEqual((Energiemenge)bo, BoMapper.MapObject<Energiemenge>((JObject)json["input"], lenients));
* Assert.AreEqual((Energiemenge)bo, JsonConvert.DeserializeObject<Energiemenge>(json["input"].ToString(), BoMapper.GetJsonSerializerSettings(lenients)));
* break;
* case "messlokation":
* //Assert.AreEqual((Messlokation)bo, BoMapper.MapObject<Messlokation>((JObject)json["input"], lenients));
* Assert.AreEqual((Messlokation)bo, JsonConvert.DeserializeObject<Messlokation>(json["input"].ToString(), BoMapper.GetJsonSerializerSettings(lenients)));
* break;
* // add more if you feel like
* }
* }*/
HashSet <string> whitelist;
if (json["userPropWhiteList"] != null)
{
whitelist = new HashSet <string>(JArray.FromObject(json["userPropWhiteList"]).ToObject <List <string> >());
}
else
{
whitelist = new HashSet <string>();
}
if (lenients == LenientParsing.Strict)
{
foreach (LenientParsing lenient in Enum.GetValues(typeof(LenientParsing)))
{
// strict mappings must also work with lenient mapping
BusinessObject boLenient;
try
{
boLenient = JsonConvert.DeserializeObject <BusinessObject>(json["input"].ToString(), lenient.GetJsonSerializerSettings(whitelist));
}
catch (ArgumentException)
{
boLenient = BoMapper.MapObject(json["objectName"].ToString(), (JObject)json["input"], whitelist, lenient);
}
catch (JsonSerializationException jse)
{
Assert.IsTrue(false, $"Unexpected {nameof(JsonSerializationException)} in file {file}: {jse.Message}");
throw jse;
}
//string dateLenietOutputString = JsonConvert.SerializeObject(boLenient, new StringEnumConverter());
//if (whitelist.Count ==0) {
//Assert.AreEqual(regularOutputString, dateLenietOutputString);
//}
//else
// {
// Assert.AreEqual(regularOutputString, dateLenietOutputString);
//}
}
}
else
{
// non-strict test cases are designed such that they are not parseble in strict mode.
// bool exceptionThrown;
// try
//{
// BusinessObject boStrict = BoMapper.MapObject(json["objectName"].ToString(), (JObject)json["input"], LenientParsing.Strict);
// exceptionThrown = false;
//}
//catch (Exception)
//{
// exceptionThrown = true;
// }
//Assert.IsTrue(exceptionThrown);
}
}
}