public void RatingCurveValueService_PostDeleteRatingCurveValue_IsContactOK_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
using (ShimsContext.Create())
{
SetupShim();
string ErrorText = "ErrorText";
shimRatingCurveValueService.IsContactOK = () =>
{
return(new ContactOK()
{
Error = ErrorText
});
};
RatingCurveValueModel ratingCurveValueModelRet2 = ratingCurveValueService.PostDeleteRatingCurveValueDB(ratingCurveValueModelRet.RatingCurveValueID);
Assert.AreEqual(ErrorText, ratingCurveValueModelRet2.Error);
}
}
}
}
public void RatingCurveValueService_PostUpdateRatingCurveValue_DoUpdateChanges_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
using (ShimsContext.Create())
{
SetupShim();
string ErrorText = "ErrorText";
shimRatingCurveValueService.DoUpdateChanges = () =>
{
return(ErrorText);
};
RatingCurveValueModel ratingCurveValueModelRet2 = UpdateRatingCurveValueModel(ratingCurveValueModelRet);
Assert.AreEqual(ErrorText, ratingCurveValueModelRet2.Error);
}
}
}
}
public void RatingCurveValueService_PostUpdateRatingCurveValue_GetRatingCurveValueWithRatingCurveValueIDDB_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
using (ShimsContext.Create())
{
SetupShim();
//string ErrorText = "ErrorText";
shimRatingCurveValueService.GetRatingCurveValueWithRatingCurveValueIDDBInt32 = (a) =>
{
return(null);
};
RatingCurveValueModel ratingCurveValueModelRet2 = UpdateRatingCurveValueModel(ratingCurveValueModelRet);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.RatingCurveValue), ratingCurveValueModelRet2.Error);
}
}
}
}
public RatingCurveValueModel AddRatingCurveValueModel()
{
RatingCurveModel ratingCurveModel = ratingCurveServiceTest.AddRatingCurveModel();
if (!string.IsNullOrWhiteSpace(ratingCurveModel.Error))
{
return(new RatingCurveValueModel()
{
Error = ratingCurveModel.Error
});
}
ratingCurveValueModelNew.RatingCurveID = ratingCurveModel.RatingCurveID;
FillRatingCurveValueModel(ratingCurveValueModelNew);
RatingCurveValueModel ratingCurveValueModelRet = ratingCurveValueService.PostAddRatingCurveValueDB(ratingCurveValueModelNew);
if (!string.IsNullOrWhiteSpace(ratingCurveValueModelRet.Error))
{
return(ratingCurveValueModelRet);
}
CompareRatingCurveValueModels(ratingCurveValueModelNew, ratingCurveValueModelRet);
return(ratingCurveValueModelRet);
}
public void RatingCurveValueService_FillRatingCurveValue_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveModelRet = AddRatingCurveValueModel();
Assert.AreEqual("", ratingCurveModelRet.Error);
ratingCurveValueModelNew.RatingCurveID = ratingCurveModelRet.RatingCurveID;
FillRatingCurveValueModel(ratingCurveValueModelNew);
ContactOK contactOK = ratingCurveValueService.IsContactOK();
string retStr = ratingCurveValueService.FillRatingCurveValue(ratingCurveValue, ratingCurveValueModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactOK.ContactTVItemID, ratingCurveValue.LastUpdateContactTVItemID);
contactOK = null;
retStr = ratingCurveValueService.FillRatingCurveValue(ratingCurveValue, ratingCurveValueModelNew, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(2, ratingCurveValue.LastUpdateContactTVItemID);
}
}
}
// Check
public string RatingCurveValueModelOK(RatingCurveValueModel ratingCurveValueModel)
{
string retStr = FieldCheckNotZeroInt(ratingCurveValueModel.RatingCurveID, ServiceRes.RatingCurveID);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(ratingCurveValueModel.StageValue_m, ServiceRes.StageValue_m, -1, 10000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(ratingCurveValueModel.DischargeValue_m3_s, ServiceRes.DischargeValue_m3_s, 0, 100000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = _BaseEnumService.DBCommandOK(ratingCurveValueModel.DBCommand);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
return("");
}
public RatingCurveValue GetRatingCurveValueExistDB(RatingCurveValueModel ratingCurveValueModel)
{
RatingCurveValue ratingCurveValue = (from c in db.RatingCurveValues
where c.RatingCurveID == ratingCurveValueModel.RatingCurveID &&
c.StageValue_m == ratingCurveValueModel.StageValue_m &&
c.DischargeValue_m3_s == ratingCurveValueModel.DischargeValue_m3_s
select c).FirstOrDefault <RatingCurveValue>();
return(ratingCurveValue);
}
private void FillRatingCurveValueModel(RatingCurveValueModel ratingCurveValueModel)
{
ratingCurveValueModel.RatingCurveID = ratingCurveValueModel.RatingCurveID;
ratingCurveValueModel.StageValue_m = randomService.RandomDouble(0, 10000);
ratingCurveValueModel.DischargeValue_m3_s = randomService.RandomDouble(0, 100000);
Assert.IsTrue(ratingCurveValueModel.RatingCurveID != 0);
Assert.IsTrue(ratingCurveValueModel.StageValue_m >= 0 && ratingCurveValueModel.StageValue_m <= 10000);
Assert.IsTrue(ratingCurveValueModel.DischargeValue_m3_s >= 0 && ratingCurveValueModel.DischargeValue_m3_s <= 100000);
}
public void RatingCurveValueService_PostAddRatingCurveValueAndRatingCurveValueLanguageDB_BadUser_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListBad[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
Assert.AreEqual(ServiceRes.NeedToBeLoggedIn, ratingCurveValueModelRet.Error);
}
}
}
public void RatingCurveValueService_PostAddRatingCurveValueDB_UserEmailNotValidated_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[2], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
Assert.AreEqual(ServiceRes.EmailRequiresValidation, ratingCurveValueModelRet.Error);
}
}
}
// Post
public RatingCurveValueModel PostAddRatingCurveValueDB(RatingCurveValueModel ratingCurveValueModel)
{
string retStr = RatingCurveValueModelOK(ratingCurveValueModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
RatingCurveValue ratingCurveValueExist = GetRatingCurveValueExistDB(ratingCurveValueModel);
if (ratingCurveValueExist != null)
{
return(ReturnError(string.Format(ServiceRes._AlreadyExists, ServiceRes.RatingCurveValue)));
}
RatingCurveValue ratingCurveValueNew = new RatingCurveValue();
retStr = FillRatingCurveValue(ratingCurveValueNew, ratingCurveValueModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.RatingCurveValues.Add(ratingCurveValueNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("RatingCurveValues", ratingCurveValueNew.RatingCurveValueID, LogCommandEnum.Add, ratingCurveValueNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetRatingCurveValueModelWithRatingCurveValueIDDB(ratingCurveValueNew.RatingCurveValueID));
}
public void RatingCurveValueService_ReturnError_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
string ErrorText = "ErrorText";
RatingCurveValueModel ratingCurveValueModelRet = ratingCurveValueService.ReturnError(ErrorText);
Assert.AreEqual(ErrorText, ratingCurveValueModelRet.Error);
}
}
}
public void RatingCurveValueService_GetRatingCurveValueModelCountDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
int ratingCurveValueCount = ratingCurveValueService.GetRatingCurveValueModelCountDB();
Assert.AreEqual(testDBService.Count + 1, ratingCurveValueCount);
}
}
}
public RatingCurveValueModel UpdateRatingCurveValueModel(RatingCurveValueModel ratingCurveValueModel)
{
FillRatingCurveValueModel(ratingCurveValueModel);
RatingCurveValueModel ratingCurveValueModelRet2 = ratingCurveValueService.PostUpdateRatingCurveValueDB(ratingCurveValueModel);
if (!string.IsNullOrWhiteSpace(ratingCurveValueModelRet2.Error))
{
return(ratingCurveValueModelRet2);
}
CompareRatingCurveValueModels(ratingCurveValueModel, ratingCurveValueModelRet2);
return(ratingCurveValueModelRet2);
}
public void SetupTest(ContactModel contactModelToDo, CultureInfo culture)
{
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
contactModel = contactModelToDo;
user = new GenericPrincipal(new GenericIdentity(contactModel.LoginEmail, "Forms"), null);
ratingCurveValueService = new RatingCurveValueService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), user);
testDBService = new TestDBService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), user, TableName, Plurial);
randomService = new RandomService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), user);
ratingCurveValueModelNew = new RatingCurveValueModel();
ratingCurveValue = new RatingCurveValue();
ratingCurveServiceTest = new RatingCurveServiceTest();
ratingCurveServiceTest.SetupTest(contactModelToDo, culture);
}
public RatingCurveValueModel PostUpdateRatingCurveValueDB(RatingCurveValueModel ratingCurveValueModel)
{
string retStr = RatingCurveValueModelOK(ratingCurveValueModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
RatingCurveValue ratingCurveValueToUpdate = GetRatingCurveValueWithRatingCurveValueIDDB(ratingCurveValueModel.RatingCurveValueID);
if (ratingCurveValueToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.RatingCurveValue)));
}
retStr = FillRatingCurveValue(ratingCurveValueToUpdate, ratingCurveValueModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
retStr = DoUpdateChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("RatingCurveValues", ratingCurveValueToUpdate.RatingCurveValueID, LogCommandEnum.Change, ratingCurveValueToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetRatingCurveValueModelWithRatingCurveValueIDDB(ratingCurveValueToUpdate.RatingCurveValueID));
}
public void RatingCurveValueService_PostAddUpdateDeleteRatingCurveValue_Good_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
RatingCurveValueModel ratingCurveValueModelRet2 = UpdateRatingCurveValueModel(ratingCurveValueModelRet);
RatingCurveValueModel ratingCurveValueModelRet3 = ratingCurveValueService.PostDeleteRatingCurveValueDB(ratingCurveValueModelRet2.RatingCurveValueID);
Assert.AreEqual("", ratingCurveValueModelRet3.Error);
}
}
}
public void RatingCurveValueService_GetRatingCurveValueWithRatingCurveValueIDDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
RatingCurveValue ratingCurveValueRet = ratingCurveValueService.GetRatingCurveValueWithRatingCurveValueIDDB(ratingCurveValueModelRet.RatingCurveValueID);
Assert.AreEqual(ratingCurveValueModelRet.RatingCurveValueID, ratingCurveValueRet.RatingCurveValueID);
RatingCurveValue ratingCurveValueRet2 = ratingCurveValueService.GetRatingCurveValueWithRatingCurveValueIDDB(0);
Assert.IsNull(ratingCurveValueRet2);
}
}
}
// Fill
public string FillRatingCurveValue(RatingCurveValue ratingCurveValueNew, RatingCurveValueModel ratingCurveValueModel, ContactOK contactOK)
{
ratingCurveValueNew.DBCommand = (int)ratingCurveValueModel.DBCommand;
ratingCurveValueNew.RatingCurveID = ratingCurveValueModel.RatingCurveID;
ratingCurveValueNew.StageValue_m = ratingCurveValueModel.StageValue_m;
ratingCurveValueNew.DischargeValue_m3_s = ratingCurveValueModel.DischargeValue_m3_s;
ratingCurveValueNew.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
ratingCurveValueNew.LastUpdateContactTVItemID = 2;
}
else
{
ratingCurveValueNew.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
public void RatingCurveValueService_GetRatingCurveValueModelListWithRatingCurveIDDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
List <RatingCurveValueModel> ratingCurveValueModelList = ratingCurveValueService.GetRatingCurveValueModelListWithRatingCurveIDDB(ratingCurveValueModelRet.RatingCurveID);
Assert.IsTrue(ratingCurveValueModelList.Where(c => c.RatingCurveValueID == ratingCurveValueModelRet.RatingCurveValueID).Any());
int RatingCurveValueID = 0;
ratingCurveValueModelList = ratingCurveValueService.GetRatingCurveValueModelListWithRatingCurveIDDB(RatingCurveValueID);
Assert.AreEqual(0, ratingCurveValueModelList.Count);
}
}
}
public void RatingCurveValueService_GetRatingCurveValueModelWithRatingCurveValueIDDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
RatingCurveValueModel ratingCurveValueModelRet2 = ratingCurveValueService.GetRatingCurveValueModelWithRatingCurveValueIDDB(ratingCurveValueModelRet.RatingCurveValueID);
Assert.AreEqual(ratingCurveValueModelRet.RatingCurveValueID, ratingCurveValueModelRet2.RatingCurveValueID);
int RatingCurveValueID = 0;
ratingCurveValueModelRet2 = ratingCurveValueService.GetRatingCurveValueModelWithRatingCurveValueIDDB(RatingCurveValueID);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.RatingCurveValue, ServiceRes.RatingCurveValueID, RatingCurveValueID), ratingCurveValueModelRet2.Error);
}
}
}
public RatingCurveValueModel GetRatingCurveValueModelWithRatingCurveValueIDDB(int RatingCurveValueID)
{
RatingCurveValueModel ratingCurveValueModel = (from c in db.RatingCurveValues
where c.RatingCurveValueID == RatingCurveValueID
select new RatingCurveValueModel
{
Error = "",
RatingCurveValueID = c.RatingCurveValueID,
DBCommand = (DBCommandEnum)c.DBCommand,
RatingCurveID = c.RatingCurveID,
StageValue_m = c.StageValue_m,
DischargeValue_m3_s = c.DischargeValue_m3_s,
LastUpdateDate_UTC = c.LastUpdateDate_UTC,
LastUpdateContactTVItemID = c.LastUpdateContactTVItemID,
}).FirstOrDefault <RatingCurveValueModel>();
if (ratingCurveValueModel == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.RatingCurveValue, ServiceRes.RatingCurveValueID, RatingCurveValueID)));
}
return(ratingCurveValueModel);
}
public void RatingCurveValueService_PostAddRatingCurveValueDB_GetRatingCurveValueExistDB_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
using (ShimsContext.Create())
{
SetupShim();
//string ErrorText = "ErrorText";
shimRatingCurveValueService.GetRatingCurveValueExistDBRatingCurveValueModel = (a) =>
{
return(new RatingCurveValue());
};
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
Assert.AreEqual(string.Format(ServiceRes._AlreadyExists, ServiceRes.RatingCurveValue), ratingCurveValueModelRet.Error);
}
}
}
}
public void RatingCurveValueService_PostAddRatingCurveValueDB_FillRatingCurveValue_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
using (ShimsContext.Create())
{
SetupShim();
string ErrorText = "ErrorText";
shimRatingCurveValueService.FillRatingCurveValueRatingCurveValueRatingCurveValueModelContactOK = (a, b, c) =>
{
return(ErrorText);
};
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
Assert.AreEqual(ErrorText, ratingCurveValueModelRet.Error);
}
}
}
}
public void RatingCurveValueService_PostAddRatingCurveValueDB_Add_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
using (ShimsContext.Create())
{
SetupShim();
//string ErrorText = "ErrorText";
shimRatingCurveValueService.FillRatingCurveValueRatingCurveValueRatingCurveValueModelContactOK = (a, b, c) =>
{
return("");
};
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
Assert.IsTrue(ratingCurveValueModelRet.Error.StartsWith(string.Format(ServiceRes.CouldNotAddError_, "").Substring(0, 10)));
}
}
}
}
private void CompareRatingCurveValueModels(RatingCurveValueModel ratingCurveValueModelNew, RatingCurveValueModel ratingCurveValueModelRet)
{
Assert.AreEqual(ratingCurveValueModelNew.RatingCurveID, ratingCurveValueModelRet.RatingCurveID);
Assert.AreEqual(ratingCurveValueModelNew.StageValue_m, ratingCurveValueModelRet.StageValue_m);
Assert.AreEqual(ratingCurveValueModelNew.DischargeValue_m3_s, ratingCurveValueModelRet.DischargeValue_m3_s);
}
public void RatingCurveValueService_RatingCurveValueModelOK_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
RatingCurveValueModel ratingCurveValueModelRet = AddRatingCurveValueModel();
Assert.AreEqual("", ratingCurveValueModelRet.Error);
#region Good
ratingCurveValueModelNew.RatingCurveID = ratingCurveValueModelRet.RatingCurveID;
FillRatingCurveValueModel(ratingCurveValueModelNew);
string retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual("", retStr);
#endregion Good
#region RatingCurveID
FillRatingCurveValueModel(ratingCurveValueModelNew);
ratingCurveValueModelNew.RatingCurveID = 0;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.RatingCurveID), retStr);
ratingCurveValueModelNew.RatingCurveID = ratingCurveValueModelRet.RatingCurveID;
FillRatingCurveValueModel(ratingCurveValueModelNew);
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual("", retStr);
#endregion RatingCurveID
#region StageValue_m
FillRatingCurveValueModel(ratingCurveValueModelNew);
double Min = -1D;
double Max = 10000D;
ratingCurveValueModelNew.StageValue_m = Min - 1;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.StageValue_m, Min, Max), retStr);
FillRatingCurveValueModel(ratingCurveValueModelNew);
ratingCurveValueModelNew.StageValue_m = Max + 1;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.StageValue_m, Min, Max), retStr);
FillRatingCurveValueModel(ratingCurveValueModelNew);
ratingCurveValueModelNew.StageValue_m = Max - 1;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual("", retStr);
FillRatingCurveValueModel(ratingCurveValueModelNew);
ratingCurveValueModelNew.StageValue_m = Min;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual("", retStr);
FillRatingCurveValueModel(ratingCurveValueModelNew);
ratingCurveValueModelNew.StageValue_m = Max;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual("", retStr);
#endregion StageValue_m
#region DischargeValue_m3_s
FillRatingCurveValueModel(ratingCurveValueModelNew);
Min = 0D;
Max = 100000D;
ratingCurveValueModelNew.DischargeValue_m3_s = Min - 1;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.DischargeValue_m3_s, Min, Max), retStr);
FillRatingCurveValueModel(ratingCurveValueModelNew);
ratingCurveValueModelNew.DischargeValue_m3_s = Max + 1;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.DischargeValue_m3_s, Min, Max), retStr);
FillRatingCurveValueModel(ratingCurveValueModelNew);
ratingCurveValueModelNew.DischargeValue_m3_s = Max - 1;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual("", retStr);
FillRatingCurveValueModel(ratingCurveValueModelNew);
ratingCurveValueModelNew.DischargeValue_m3_s = Min;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual("", retStr);
FillRatingCurveValueModel(ratingCurveValueModelNew);
ratingCurveValueModelNew.DischargeValue_m3_s = Max;
retStr = ratingCurveValueService.RatingCurveValueModelOK(ratingCurveValueModelNew);
Assert.AreEqual("", retStr);
#endregion DischargeValue_m3_s
}
}
}
