public void VerifyThatStateDependentParameterOverrideValueSetReturnsExpectedModelCode()
{
var possibleFiniteStateList = new PossibleFiniteStateList();
var possibleFiniteState = new PossibleFiniteState();
possibleFiniteState.ShortName = "SM";
possibleFiniteStateList.PossibleState.Add(possibleFiniteState);
var actualFiniteStateList = new ActualFiniteStateList();
actualFiniteStateList.PossibleFiniteStateList.Add(possibleFiniteStateList);
var actualFiniteState = new ActualFiniteState();
actualFiniteState.PossibleState.Add(possibleFiniteState);
actualFiniteStateList.ActualState.Add(actualFiniteState);
this.scalarParameter.StateDependence = actualFiniteStateList;
var parameterValueSet = this.scalarParameter.ValueSet.Single();
parameterValueSet.ActualState = actualFiniteState;
var parameterOverride = new ParameterOverride();
parameterOverride.Parameter = this.scalarParameter;
this.elementUsage.ParameterOverride.Add(parameterOverride);
var parameterOverrideValueSet = new ParameterOverrideValueSet();
parameterOverrideValueSet.ParameterValueSet = parameterValueSet;
parameterOverride.ValueSet.Add(parameterOverrideValueSet);
parameterOverrideValueSet.ParameterValueSet = parameterValueSet;
Assert.AreEqual(@"Sat.battery_1.l\SM", parameterOverrideValueSet.ModelCode(0));
}
public void VerifyThatParameterOverrideRowWorksNoOptionNoState()
{
var value = new List <string> {
"test"
};
var parameterValue = new ParameterValueSet(Guid.NewGuid(), null, this.uri);
parameterValue.Manual = new ValueArray <string>(value);
parameterValue.Reference = new ValueArray <string>(value);
parameterValue.Computed = new ValueArray <string>(value);
parameterValue.Published = new ValueArray <string>(value);
this.parameter.ValueSet.Add(parameterValue);
var poverride = new ParameterOverride(Guid.NewGuid(), null, this.uri)
{
Parameter = this.parameter
};
var valueset = new ParameterOverrideValueSet(Guid.NewGuid(), null, this.uri)
{
ParameterValueSet = parameterValue
};
valueset.Manual = new ValueArray <string>(value);
poverride.ValueSet.Add(valueset);
this.elementUsage1.ParameterOverride.Add(poverride);
var row = new ParameterOverrideRowViewModel(poverride, this.session.Object, null);
Assert.AreEqual("test", row.Manual);
Assert.AreEqual("-", row.Reference);
Assert.AreEqual(0, row.ContainedRows.Count);
}
/// <summary>
/// Gets the <see cref="ParameterOverrideValueSet"/> of this <see cref="ParameterOverride"/> if applicable
/// </summary>
/// <returns>The <see cref="ParameterOverrideValueSet"/></returns>
private ParameterOverrideValueSet GetParameterOverrideValueSet()
{
var parameterOverride = (ParameterOverride)this.Thing;
ParameterOverrideValueSet valueSet = null;
if (this.ActualOption == null && this.ActualState == null)
{
return(parameterOverride.ValueSet.FirstOrDefault());
}
if (this.ActualOption != null && this.ActualState == null)
{
valueSet = parameterOverride.ValueSet.FirstOrDefault(v => v.ActualOption == this.ActualOption);
}
if (this.ActualOption == null && this.ActualState != null)
{
valueSet = parameterOverride.ValueSet.FirstOrDefault(v => v.ActualState == this.ActualState);
}
if (this.ActualOption != null && this.ActualState != null)
{
valueSet = parameterOverride.ValueSet.FirstOrDefault(v => v.ActualOption == this.ActualOption && v.ActualState == this.ActualState);
}
return(valueSet);
}
public void VerifyThatToBePublishedReturnsExpectedResult()
{
var valuesetoverriden = new ParameterValueSet(Guid.NewGuid(), null, null);
var valueset = new ParameterOverrideValueSet(Guid.NewGuid(), null, null)
{
ParameterValueSet = valuesetoverriden
};
var data = new List <string> {
"-"
};
valueset.ValueSwitch = ParameterSwitchKind.MANUAL;
valueset.Manual = new ValueArray <string>(data);
valueset.Computed = new ValueArray <string>(data);
valueset.Reference = new ValueArray <string>(data);
valueset.Published = new ValueArray <string>(data);
valueset.Formula = new ValueArray <string>(data);
this.parameterOverride.ValueSet.Add(valueset);
Assert.IsFalse(this.parameterOverride.ToBePublished);
this.parameterOverride.ToBePublished = true;
Assert.IsFalse(this.parameterOverride.ToBePublished);
var updatedData = new List <string> {
"1"
};
valueset.Manual = new ValueArray <string>(updatedData);
Assert.IsTrue(this.parameterOverride.ToBePublished);
}
public void VerifyThatParameterHasNoError()
{
var valuesetoverriden = new ParameterValueSet(Guid.NewGuid(), null, null);
var valueset = new ParameterOverrideValueSet(Guid.NewGuid(), null, null)
{
ParameterValueSet = valuesetoverriden
};
var data = new List <string> {
"-"
};
valueset.Manual = new ValueArray <string>(data);
valueset.Computed = new ValueArray <string>(data);
valueset.Reference = new ValueArray <string>(data);
valueset.Published = new ValueArray <string>(data);
valueset.Formula = new ValueArray <string>(data);
this.parameter.IsOptionDependent = false;
this.parameter.StateDependence = null;
this.parameterOverride.ValueSet.Add(valueset);
valueset.ValidatePoco();
this.parameterOverride.ValidatePoco();
Assert.IsEmpty(this.parameterOverride.ValidationErrors);
}
/// <summary>
/// Update the values, formula and switch of the provided <see cref="ParameterOverrideValueSet"/>
/// </summary>
/// <param name="clone">
/// The clone of the <see cref="ParameterOverrideValueSet"/> that is to be updated.
/// </param>
/// <param name="valueSetValues">
/// The <see cref="ValueSetValues"/> used to update the <see cref="ParameterOverrideValueSet"/> clone with
/// </param>
private void UpdateClone(ParameterOverrideValueSet clone, ValueSetValues valueSetValues)
{
try
{
clone.Manual[valueSetValues.ComponentIndex] = valueSetValues.ManualValue;
}
catch (ArgumentOutOfRangeException)
{
clone.ResetManual();
clone.Manual[valueSetValues.ComponentIndex] = valueSetValues.ManualValue;
}
catch (Exception exception)
{
throw exception;
}
try
{
clone.Computed[valueSetValues.ComponentIndex] = valueSetValues.ComputedValue;
}
catch (ArgumentOutOfRangeException)
{
clone.ResetComputed();
clone.Computed[valueSetValues.ComponentIndex] = valueSetValues.ComputedValue;
}
catch (Exception exception)
{
throw exception;
}
try
{
clone.Formula[valueSetValues.ComponentIndex] = valueSetValues.FormulaValue;
}
catch (ArgumentOutOfRangeException)
{
clone.ResetFormula();
clone.Formula[valueSetValues.ComponentIndex] = valueSetValues.FormulaValue;
}
catch (Exception exception)
{
throw exception;
}
try
{
clone.Reference[valueSetValues.ComponentIndex] = valueSetValues.ReferenceValue;
}
catch (ArgumentOutOfRangeException)
{
clone.ResetReference();
clone.Reference[valueSetValues.ComponentIndex] = valueSetValues.ReferenceValue;
}
catch (Exception exception)
{
throw exception;
}
clone.ValueSwitch = valueSetValues.SwitchKind;
}
public void VerifyThatParameterOverrideRowWorksNoOptionWithState()
{
var value = new List <string> {
"test"
};
var set1 = new ParameterValueSet(Guid.NewGuid(), null, this.uri);
set1.ActualState = this.actualState1;
set1.Manual = new ValueArray <string>(value);
set1.Reference = new ValueArray <string>(value);
set1.Computed = new ValueArray <string>(value);
set1.Published = new ValueArray <string>(value);
var set2 = new ParameterValueSet(Guid.NewGuid(), null, this.uri);
set2.ActualState = this.actualState2;
set2.Manual = new ValueArray <string>(value);
set2.Reference = new ValueArray <string>(value);
set2.Computed = new ValueArray <string>(value);
set2.Published = new ValueArray <string>(value);
this.parameter.ValueSet.Add(set1);
this.parameter.ValueSet.Add(set2);
this.parameter.StateDependence = this.stateList;
var poverride = new ParameterOverride(Guid.NewGuid(), null, this.uri)
{
Parameter = this.parameter
};
var valueset1 = new ParameterOverrideValueSet(Guid.NewGuid(), null, this.uri)
{
ParameterValueSet = set1
};
var valueset2 = new ParameterOverrideValueSet(Guid.NewGuid(), null, this.uri)
{
ParameterValueSet = set2
};
valueset1.Manual = new ValueArray <string>(value);
valueset2.Reference = new ValueArray <string>(value);
poverride.ValueSet.Add(valueset1);
poverride.ValueSet.Add(valueset2);
this.elementUsage1.ParameterOverride.Add(poverride);
var row = new ParameterOverrideRowViewModel(poverride, this.session.Object, null);
Assert.AreEqual(2, row.ContainedRows.Count);
var s1row =
row.ContainedRows.OfType <ParameterStateRowViewModel>().Single(x => x.ActualState == this.actualState1);
var s2row =
row.ContainedRows.OfType <ParameterStateRowViewModel>().Single(x => x.ActualState == this.actualState2);
Assert.AreEqual(s1row.Manual, "test");
Assert.AreEqual(s2row.Reference, "test");
}
public void VerifyThatOptionDependentParameterOverrideValueSetReturnsExpectedModelCode()
{
var option = new Option();
option.ShortName = "option_1";
var parameterValueSet = this.scalarParameter.ValueSet.Single();
parameterValueSet.ActualOption = option;
this.scalarParameter.IsOptionDependent = true;
var parameterOverride = new ParameterOverride();
parameterOverride.Parameter = this.scalarParameter;
this.elementUsage.ParameterOverride.Add(parameterOverride);
var parameterOverrideValueSet = new ParameterOverrideValueSet();
parameterOverride.ValueSet.Add(parameterOverrideValueSet);
parameterOverrideValueSet.ParameterValueSet = parameterValueSet;
Assert.AreEqual(@"Sat.battery_1.l\option_1", parameterOverrideValueSet.ModelCode(0));
}
/// <summary>
/// Queries the container of the <see cref="ParameterOverrideValueSet"/> for the <see cref="ParameterType"/> and <see cref="MeasurementScale"/>
/// </summary>
/// <param name="parameterOverrideValueSet">
/// The subject <see cref="ParameterOverrideValueSet"/>
/// </param>
/// <param name="componentIndex">
/// The index of the <see cref="ParameterTypeComponent"/>.
/// </param>
/// <param name="parameterType">
/// The resulting <see cref="ParameterType"/>
/// </param>
/// <param name="measurementScale">
/// The resulting <see cref="MeasurementScale"/>, this may be null if the <see cref="ParameterType"/> is not a <see cref="QuantityKind"/>
/// </param>
public static void QueryParameterTypeAndScale(ParameterOverrideValueSet parameterOverrideValueSet, int componentIndex, out ParameterType parameterType, out MeasurementScale measurementScale)
{
var parameterOverride = (ParameterOverride)parameterOverrideValueSet.Container;
var scalarParameterType = parameterOverride.ParameterType as ScalarParameterType;
if (scalarParameterType != null)
{
parameterType = scalarParameterType;
measurementScale = parameterOverride.Scale;
return;
}
var compoundParameterType = parameterOverride.ParameterType as CompoundParameterType;
if (compoundParameterType != null)
{
var component = compoundParameterType.Component[componentIndex];
parameterType = component.ParameterType;
measurementScale = component.Scale;
return;
}
logger.Debug("The ParameterType and MeasurementScale of ParameterOverrideValueSet {0} could not be queried", parameterOverrideValueSet.Iid);
parameterType = null;
measurementScale = null;
}
public void VerifyThatOptionDepStateFullValueSetsComparerCompareReturnsExpectedResults()
{
var parameter = new Parameter(Guid.NewGuid(), null, null);
parameter.IsOptionDependent = true;
var parameterValueSetaa = new ParameterValueSet();
var parameterValueSetab = new ParameterValueSet();
var parameterValueSetbb = new ParameterValueSet();
var parameterValueSetba = new ParameterValueSet();
parameter.ValueSet.Add(parameterValueSetaa);
parameter.ValueSet.Add(parameterValueSetab);
parameter.ValueSet.Add(parameterValueSetbb);
parameter.ValueSet.Add(parameterValueSetba);
parameterValueSetaa.ActualOption = this.optiona;
parameterValueSetaa.ActualState = this.actualFiniteStatea;
parameterValueSetab.ActualOption = this.optiona;
parameterValueSetab.ActualState = this.actualFiniteStateb;
parameterValueSetbb.ActualOption = this.optionb;
parameterValueSetbb.ActualState = this.actualFiniteStateb;
parameterValueSetba.ActualOption = this.optionb;
parameterValueSetba.ActualState = this.actualFiniteStatea;
var parameterOverride = new ParameterOverride();
parameterOverride.Parameter = parameter;
var aa = new ParameterOverrideValueSet();
aa.ParameterValueSet = parameterValueSetaa;
var ab = new ParameterOverrideValueSet();
ab.ParameterValueSet = parameterValueSetab;
var bb = new ParameterOverrideValueSet();
bb.ParameterValueSet = parameterValueSetbb;
var ba = new ParameterOverrideValueSet();
ba.ParameterValueSet = parameterValueSetba;
var comparer = new ParameterOverrideValueSetComparer();
var comparison_aa_ab = comparer.Compare(aa, ab);
Assert.AreEqual(1, comparison_aa_ab);
var comparison_aa_bb = comparer.Compare(aa, ab);
Assert.AreEqual(1, comparison_aa_bb);
}
public void Setup()
{
this.assembler = new Assembler(this.uri);
RxApp.MainThreadScheduler = Scheduler.CurrentThread;
this.session = new Mock <ISession>();
this.permissionService = new Mock <IPermissionService>();
this.permissionService.Setup(x => x.CanRead(It.IsAny <Thing>())).Returns(true);
this.permissionService.Setup(x => x.CanWrite(It.IsAny <Thing>())).Returns(true);
this.session.Setup(x => x.PermissionService).Returns(this.permissionService.Object);
this.session.Setup(x => x.DataSourceUri).Returns(this.uri.ToString);
this.session.Setup(x => x.Assembler).Returns(this.assembler);
this.cache = this.assembler.Cache;
this.domain = new DomainOfExpertise(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Name = "test"
};
this.iteration = new Iteration(Guid.NewGuid(), null, null);
var iterationTrackParameterTestFixture = new IterationTrackParameterTestFixture();
iterationTrackParameterTestFixture.Setup();
this.iterationTrackParameterForParameter = iterationTrackParameterTestFixture.iterationTrackParameterForParameter;
this.iterationTrackParameterForParameterOverride = iterationTrackParameterTestFixture.iterationTrackParameterForParameterOverride;
var parameterValueArray = new ValueArray <string>(new[] { "10" });
this.parameterValueSet = new ParameterValueSet(Guid.NewGuid(), null, null)
{
Published = parameterValueArray,
Manual = parameterValueArray,
ValueSwitch = ParameterSwitchKind.MANUAL
};
((Parameter)this.iterationTrackParameterForParameter.ParameterOrOverride).ValueSet.Add(this.parameterValueSet);
var parameterOverrideValueArray = new ValueArray <string>(new[] { "20" });
this.parameterOverrideValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), null, null)
{
Published = parameterOverrideValueArray,
Manual = parameterOverrideValueArray,
ValueSwitch = ParameterSwitchKind.MANUAL
};
((ParameterOverride)this.iterationTrackParameterForParameterOverride.ParameterOrOverride).ValueSet.Add(this.parameterOverrideValueSet);
this.cache.AddOrUpdate(new CacheKey(this.parameterValueSet.Iid, this.iteration.Iid), new Lazy <Thing>(() => this.parameterValueSet), (key, value) => value);
this.cache.AddOrUpdate(new CacheKey(this.parameterOverrideValueSet.Iid, this.iteration.Iid), new Lazy <Thing>(() => this.parameterOverrideValueSet), (key, value) => value);
this.cache.AddOrUpdate(new CacheKey(this.iterationTrackParameterForParameter.ParameterOrOverride.Iid, this.iteration.Iid), new Lazy <Thing>(() => this.iterationTrackParameterForParameter.ParameterOrOverride), (key, value) => value);
this.cache.AddOrUpdate(new CacheKey(this.iterationTrackParameterForParameterOverride.ParameterOrOverride.Iid, this.iteration.Iid), new Lazy <Thing>(() => this.iterationTrackParameterForParameterOverride.ParameterOrOverride), (key, value) => value);
this.iterationTrackParameterViewModel = new IterationTrackParameterViewModel <Parameter, ParameterValueSet>(this.session.Object, this.iteration, this.iterationTrackParameterForParameter);
}
public void TestGets()
{
var thing = new ParameterOverrideValueSet(Guid.NewGuid(), null, null);
var parameterValueSet = new ParameterValueSet(Guid.NewGuid(), null, null);
parameterValueSet.ActualOption = new Option(Guid.NewGuid(), null, null);
parameterValueSet.ActualState = new ActualFiniteState(Guid.NewGuid(), null, null);
thing.ParameterValueSet = parameterValueSet;
Assert.IsTrue(ReferenceEquals(parameterValueSet.ActualState, thing.ActualState));
Assert.IsTrue(ReferenceEquals(parameterValueSet.ActualOption, thing.ActualOption));
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkbookRebuildRowViewModel"/> class.
/// </summary>
/// <param name="parameterOverrideValueSet">
/// The <see cref="ParameterOverrideValueSet"/> that is represented by the current view model
/// </param>
/// <param name="componentIndex">
/// The component index.
/// </param>
/// <param name="validationResult">
/// The result of the Validation
/// </param>
public WorkbookRebuildRowViewModel(ParameterOverrideValueSet parameterOverrideValueSet, int componentIndex, ValidationResultKind validationResult)
{
this.Thing = parameterOverrideValueSet;
this.IsSelected = true;
this.ModelCode = parameterOverrideValueSet.ModelCode(componentIndex);
this.ManualValue = parameterOverrideValueSet.Manual[componentIndex];
this.ReferenceValue = parameterOverrideValueSet.Reference[componentIndex];
this.FormulaValue = parameterOverrideValueSet.Formula[componentIndex];
this.ComputedValue = parameterOverrideValueSet.Computed[componentIndex];
this.ActualValue = parameterOverrideValueSet.ActualValue[componentIndex];
this.Switch = parameterOverrideValueSet.ValueSwitch.ToString();
this.HasValidationError = validationResult != ValidationResultKind.Valid;
this.IsSelected = this.HasValidationError == false;
}
private void SetValueSet(ParameterOverride paramOverride, Parameter param, IReadOnlyList <string> values)
{
var i = 0;
foreach (var parameterValueSet in param.ValueSet)
{
var valueset = new ParameterOverrideValueSet(Guid.NewGuid(), this.cache, this.uri)
{
ParameterValueSet = parameterValueSet
};
this.SetValueSet(valueset, values[i]);
paramOverride.ValueSet.Add(valueset);
i++;
}
}
public void VerifyThatParameterOverrideValueSetReturnsExpectedModelCode()
{
var parameterOverride = new ParameterOverride();
parameterOverride.Parameter = this.scalarParameter;
this.elementUsage.ParameterOverride.Add(parameterOverride);
var parameterOverrideValueSet = new ParameterOverrideValueSet();
parameterOverride.ValueSet.Add(parameterOverrideValueSet);
parameterOverrideValueSet.ParameterValueSet = this.scalarParameter.ValueSet.Single();
Assert.AreEqual("Sat.battery_1.l", parameterOverrideValueSet.ModelCode(0));
}
public void Verify_that_Reference_Value_can_be_reset()
{
var defaultValueArray = new ValueArray <string>(new List <string> {
"-"
});
var parameterOverrideValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), null, null);
parameterOverride.ValueSet.Add(parameterOverrideValueSet);
parameterOverrideValueSet.ResetReference();
Assert.AreEqual(defaultValueArray, parameterOverrideValueSet.Reference);
parameterOverrideValueSet.ResetReference();
Assert.AreEqual(defaultValueArray, parameterOverrideValueSet.Reference);
}
public void VerifyThatCloneWithCloneValueArrayReturnsCloneWithNewValueArrays()
{
var parameterOverrideValueSet = new ParameterOverrideValueSet();
var manualValue = "manual";
var newManualValue = "new manual";
var referenceValue = "reference";
var newReferenceValue = "new referennce";
var computedValue = "computed";
var newComputedValue = "new computedValue";
var manualValueArray = new ValueArray <string>(new List <string> {
manualValue
});
var referenceValueArray = new ValueArray <string>(new List <string> {
referenceValue
});
var computedValueArray = new ValueArray <string>(new List <string> {
computedValue
});
parameterOverrideValueSet.Manual = manualValueArray;
parameterOverrideValueSet.Reference = referenceValueArray;
parameterOverrideValueSet.Computed = computedValueArray;
Assert.AreEqual(manualValue, parameterOverrideValueSet.Manual[0]);
Assert.AreEqual(referenceValue, parameterOverrideValueSet.Reference[0]);
Assert.AreEqual(computedValue, parameterOverrideValueSet.Computed[0]);
var clone = parameterOverrideValueSet.Clone(false);
clone.Manual[0] = newManualValue;
clone.Reference[0] = newReferenceValue;
clone.Computed[0] = newComputedValue;
Assert.AreEqual(newManualValue, clone.Manual[0]);
Assert.AreEqual(manualValue, parameterOverrideValueSet.Manual[0]);
Assert.AreEqual(newReferenceValue, clone.Reference[0]);
Assert.AreEqual(referenceValue, parameterOverrideValueSet.Reference[0]);
Assert.AreEqual(newComputedValue, clone.Computed[0]);
Assert.AreEqual(computedValue, parameterOverrideValueSet.Computed[0]);
}
public void SetUp()
{
this.concurentDictionary = new ConcurrentDictionary <CacheKey, Lazy <Thing> >();
this.parameterType = new TextParameterType(Guid.NewGuid(), this.concurentDictionary, this.uri);
var manualValue = new ValueArray <string>(new List <string> {
"-"
});
var computedValue = new ValueArray <string>(new List <string> {
"-"
});
var referenceValue = new ValueArray <string>(new List <string> {
"-"
});
var formula = new ValueArray <string>(new List <string> {
"-"
});
this.parameterValueSet = new ParameterValueSet(Guid.NewGuid(), this.concurentDictionary, this.uri)
{
Manual = manualValue,
Computed = computedValue,
Reference = referenceValue,
Formula = formula,
ValueSwitch = ParameterSwitchKind.MANUAL
};
this.parameterOverrideValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), this.concurentDictionary, this.uri)
{
Manual = manualValue,
Computed = computedValue,
Reference = referenceValue,
Formula = formula,
ValueSwitch = ParameterSwitchKind.MANUAL
};
this.parameterSubscriptionValueSet = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.concurentDictionary, this.uri)
{
Manual = manualValue,
ValueSwitch = ParameterSwitchKind.MANUAL
};
this.valueSetValues = new ValueSetValues(0, this.parameterType, ParameterSwitchKind.COMPUTED, "manual", "computed", "reference", "formula");
}
public void VerifyThatParameterWithEmptyArrayValueSetHasError()
{
var valuesetoverriden = new ParameterValueSet(Guid.NewGuid(), null, null);
var valueset = new ParameterOverrideValueSet(Guid.NewGuid(), null, null)
{
ParameterValueSet = valuesetoverriden
};
this.parameter.IsOptionDependent = false;
this.parameter.StateDependence = null;
this.parameterOverride.ValueSet.Add(valueset);
valueset.ValidatePoco();
this.parameterOverride.ValidatePoco();
Assert.IsNotEmpty(this.parameterOverride.ValidationErrors);
}
public void VerifyThatParameterBaseValueSetWorks()
{
var parameter = new Parameter();
var poverride = new ParameterOverride();
var subscription = new ParameterSubscription();
var parameterValueSet = new ParameterValueSet();
var overrideValueset = new ParameterOverrideValueSet();
var subscriptionValueset = new ParameterSubscriptionValueSet();
parameter.ValueSet.Add(parameterValueSet);
poverride.ValueSet.Add(overrideValueset);
subscription.ValueSet.Add(subscriptionValueset);
Assert.AreSame(parameter.ValueSet, parameter.ValueSets);
Assert.AreSame(poverride.ValueSet, poverride.ValueSets);
Assert.AreSame(subscription.ValueSet, subscription.ValueSets);
}
public void VerifyThatParameterOverrideValueSetQueryParameterTypeAndScaleReturnsExpectedResult()
{
var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), null, null);
var ratioScale = new RatioScale(Guid.NewGuid(), null, null);
var parameter = new Parameter(Guid.NewGuid(), null, null)
{
ParameterType = simpleQuantityKind,
Scale = ratioScale
};
var paramterValueSet = new ParameterValueSet(Guid.NewGuid(), null, null);
parameter.ValueSet.Add(paramterValueSet);
var parameterOverride = new ParameterOverride(Guid.NewGuid(), null, null);
parameterOverride.Parameter = parameter;
var parameterOverrideValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), null, null);
parameterOverride.ValueSet.Add(parameterOverrideValueSet);
ParameterType parameterType;
MeasurementScale measurementScale;
ParameterSheetUtilities.QueryParameterTypeAndScale(parameterOverrideValueSet, 0, out parameterType, out measurementScale);
Assert.AreEqual(simpleQuantityKind, parameterType);
Assert.AreEqual(ratioScale, measurementScale);
var compoundParameterType = new CompoundParameterType(Guid.NewGuid(), null, null);
var component = new ParameterTypeComponent(Guid.NewGuid(), null, null);
compoundParameterType.Component.Add(component);
component.ParameterType = simpleQuantityKind;
component.Scale = ratioScale;
parameter.ParameterType = compoundParameterType;
parameter.Scale = null;
ParameterSheetUtilities.QueryParameterTypeAndScale(parameterOverrideValueSet, 0, out parameterType, out measurementScale);
Assert.AreEqual(simpleQuantityKind, parameterType);
Assert.AreEqual(ratioScale, measurementScale);
}
public void VerifyThatStateFullValueSetsComparerCompareReturnsExpectedResults()
{
var parameter = new Parameter(Guid.NewGuid(), null, null);
parameter.IsOptionDependent = true;
var parameterValueSeta = new ParameterValueSet();
var parameterValueSetb = new ParameterValueSet();
parameter.ValueSet.Add(parameterValueSeta);
parameter.ValueSet.Add(parameterValueSetb);
parameterValueSeta.ActualState = this.actualFiniteStatea;
parameterValueSetb.ActualState = this.actualFiniteStateb;
var parameterOverride = new ParameterOverride();
parameterOverride.Parameter = parameter;
var parameterOverrideValueSeta = new ParameterOverrideValueSet();
parameterOverrideValueSeta.ParameterValueSet = parameterValueSeta;
var parameterOverrideValueSetb = new ParameterOverrideValueSet();
parameterOverrideValueSetb.ParameterValueSet = parameterValueSetb;
var comparer = new ParameterOverrideValueSetComparer();
var comparisonab = comparer.Compare(parameterOverrideValueSeta, parameterOverrideValueSetb);
Assert.AreEqual(1, comparisonab);
var comparisonba = comparer.Compare(parameterOverrideValueSetb, parameterOverrideValueSeta);
Assert.AreEqual(-1, comparisonba);
var comparisonaa = comparer.Compare(parameterOverrideValueSeta, parameterOverrideValueSeta);
Assert.AreEqual(0, comparisonaa);
var comparisonbb = comparer.Compare(parameterOverrideValueSetb, parameterOverrideValueSetb);
Assert.AreEqual(0, comparisonbb);
}
public void VerifyThatParameterOverrideRowWorks()
{
var value = new List <string> {
"test"
};
var parameterValue = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri);
parameterValue.Manual = new ValueArray <string>(value);
parameterValue.Reference = new ValueArray <string>(value);
parameterValue.Computed = new ValueArray <string>(value);
parameterValue.Published = new ValueArray <string>(value);
this.parameter.ValueSet.Add(parameterValue);
var poverride = new ParameterOverride(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Parameter = this.parameter
};
var valueset = new ParameterOverrideValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
ParameterValueSet = parameterValue
};
valueset.Manual = new ValueArray <string>(value);
poverride.ValueSet.Add(valueset);
this.elementUsage1.ParameterOverride.Add(poverride);
var row = new ParameterOverrideRowViewModel(poverride, this.session.Object, null);
Assert.AreEqual("test", row.Manual);
Assert.AreEqual("-", row.Reference);
Assert.AreEqual(0, row.ContainedRows.Count);
this.parameter.StateDependence = this.stateList;
var rev = typeof(Thing).GetProperty("RevisionNumber");
rev.SetValue(this.parameter, 10);
CDPMessageBus.Current.SendObjectChangeEvent(this.parameter, EventKind.Updated);
Assert.AreEqual(2, row.ContainedRows.Count);
}
public void verifyThatOptionDependentValuesetsComparerCompareReturnsExpectedResults()
{
var parameter = new Parameter(Guid.NewGuid(), null, null);
parameter.IsOptionDependent = true;
var parameterValueSeta = new ParameterValueSet();
var parameterValueSetb = new ParameterValueSet();
parameter.ValueSet.Add(parameterValueSeta);
parameter.ValueSet.Add(parameterValueSetb);
parameterValueSeta.ActualOption = this.optiona;
parameterValueSetb.ActualOption = this.optionb;
var parameterOverride = new ParameterOverride();
parameterOverride.Parameter = parameter;
var parameterOverrideValueSeta = new ParameterOverrideValueSet();
parameterOverrideValueSeta.ParameterValueSet = parameterValueSeta;
var optiondepaparametervaluesetb = new ParameterOverrideValueSet();
optiondepaparametervaluesetb.ParameterValueSet = parameterValueSetb;
var comparer = new ParameterOverrideValueSetComparer();
var comparisonab = comparer.Compare(parameterOverrideValueSeta, optiondepaparametervaluesetb);
Assert.AreEqual(1, comparisonab);
var comparisonba = comparer.Compare(optiondepaparametervaluesetb, parameterOverrideValueSeta);
Assert.AreEqual(-1, comparisonba);
var comparisonaa = comparer.Compare(parameterOverrideValueSeta, parameterOverrideValueSeta);
Assert.AreEqual(0, comparisonaa);
var comparisonbb = comparer.Compare(optiondepaparametervaluesetb, optiondepaparametervaluesetb);
Assert.AreEqual(0, comparisonbb);
}
/// <summary>
/// Create a new <see cref="ParameterOverrideValueSet"/> given a source <see cref="ParameterOverrideValueSet"/>
/// </summary>
/// <param name="sourceValueSet">The source <see cref="ParameterOverrideValueSet"/></param>
/// <param name="parameterValueSet">The associated <see cref="ParameterValueSet"/></param>
/// <returns>The new <see cref="ParameterOverrideValueSet"/></returns>
public ParameterOverrideValueSet CreateWithOldValues(ParameterOverrideValueSet sourceValueSet, ParameterValueSet parameterValueSet)
{
if (sourceValueSet == null)
{
return(this.CreateParameterOverrideValueSet(parameterValueSet));
}
var parameterOverrideValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), -1)
{
ParameterValueSet = parameterValueSet.Iid,
Manual = sourceValueSet.Manual,
Computed = sourceValueSet.Computed,
Reference = sourceValueSet.Reference,
Formula = sourceValueSet.Formula,
Published = sourceValueSet.Published,
ValueSwitch = sourceValueSet.ValueSwitch
};
return(parameterOverrideValueSet);
}
/// <summary>
/// Creates a new <see cref="ParameterOverrideValueSet"/> where all the values are equal to a <see cref="ValueArray{String}"/> where each slot is a "-"
/// and the <see cref="CDP4Common.EngineeringModelData.ParameterSwitchKind"/> is set to <see cref="CDP4Common.EngineeringModelData.ParameterSwitchKind.MANUAL"/>
/// </summary>
/// <param name="parameterValueSetIid">
/// The unique Id of the <see cref="ParameterValueSet"/> that is referenced by the <see cref="ParameterOverrideValueSet"/>
/// </param>
/// <param name="valueArray">
/// A <see cref="ValueArray{String}"/> where each slot is a "-"
/// </param>
/// <returns>
/// A instance of <see cref="ParameterOverrideValueSet"/>
/// </returns>
public ParameterOverrideValueSet CreateWithDefaultValueArray(Guid parameterValueSetIid, ValueArray <string> valueArray)
{
if (valueArray.Any(value => value != "-"))
{
throw new ArgumentException("The valueArray must be a default valueArray that only contains \"-\"", nameof(valueArray));
}
var parameterOverrideValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), -1)
{
ParameterValueSet = parameterValueSetIid,
Manual = valueArray,
Computed = valueArray,
Reference = valueArray,
Formula = valueArray,
Published = valueArray,
ValueSwitch = CDP4Common.EngineeringModelData.ParameterSwitchKind.MANUAL
};
return(parameterOverrideValueSet);
}
/// <summary>
/// Creates a new <see cref="ParameterOverrideValueSet"/> from a <see cref="ParameterValueSet"/>
/// </summary>
/// <param name="parameterValueSet">The <see cref="ParameterValueSet"/></param>
/// <returns>The <see cref="ParameterOverrideValueSet"/></returns>
public ParameterOverrideValueSet CreateParameterOverrideValueSet(ParameterValueSet parameterValueSet)
{
if (parameterValueSet == null)
{
throw new ArgumentNullException(nameof(parameterValueSet), "The source ParameterValueSet cannot be null");
}
var parameterOverrideValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), -1)
{
ParameterValueSet = parameterValueSet.Iid,
Manual = parameterValueSet.Manual,
Computed = parameterValueSet.Computed,
Reference = parameterValueSet.Reference,
Formula = parameterValueSet.Formula,
Published = parameterValueSet.Published,
ValueSwitch = parameterValueSet.ValueSwitch
};
return(parameterOverrideValueSet);
}
/// <summary>
/// Serialize the <see cref="ParameterOverrideValueSet"/>
/// </summary>
/// <param name="parameterOverrideValueSet">The <see cref="ParameterOverrideValueSet"/> to serialize</param>
/// <returns>The <see cref="JObject"/></returns>
private JObject Serialize(ParameterOverrideValueSet parameterOverrideValueSet)
{
var jsonObject = new JObject();
jsonObject.Add("classKind", this.PropertySerializerMap["classKind"](Enum.GetName(typeof(CDP4Common.CommonData.ClassKind), parameterOverrideValueSet.ClassKind)));
jsonObject.Add("computed", this.PropertySerializerMap["computed"](parameterOverrideValueSet.Computed));
jsonObject.Add("excludedDomain", this.PropertySerializerMap["excludedDomain"](parameterOverrideValueSet.ExcludedDomain.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("excludedPerson", this.PropertySerializerMap["excludedPerson"](parameterOverrideValueSet.ExcludedPerson.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("formula", this.PropertySerializerMap["formula"](parameterOverrideValueSet.Formula));
jsonObject.Add("iid", this.PropertySerializerMap["iid"](parameterOverrideValueSet.Iid));
jsonObject.Add("manual", this.PropertySerializerMap["manual"](parameterOverrideValueSet.Manual));
jsonObject.Add("modifiedOn", this.PropertySerializerMap["modifiedOn"](parameterOverrideValueSet.ModifiedOn));
jsonObject.Add("parameterValueSet", this.PropertySerializerMap["parameterValueSet"](parameterOverrideValueSet.ParameterValueSet));
jsonObject.Add("published", this.PropertySerializerMap["published"](parameterOverrideValueSet.Published));
jsonObject.Add("reference", this.PropertySerializerMap["reference"](parameterOverrideValueSet.Reference));
jsonObject.Add("revisionNumber", this.PropertySerializerMap["revisionNumber"](parameterOverrideValueSet.RevisionNumber));
jsonObject.Add("thingPreference", this.PropertySerializerMap["thingPreference"](parameterOverrideValueSet.ThingPreference));
jsonObject.Add("valueSwitch", this.PropertySerializerMap["valueSwitch"](Enum.GetName(typeof(CDP4Common.EngineeringModelData.ParameterSwitchKind), parameterOverrideValueSet.ValueSwitch)));
return(jsonObject);
}
private void AddParameterOverride(
ElementUsage elementUsage,
ParameterType parameterType,
DomainOfExpertise owner,
ParameterValueSet parameterValueSet,
string value)
{
var parameter = elementUsage.ElementDefinition.Parameter
.First(p => p.ParameterType == parameterType);
var parameterOverride = new ParameterOverride(Guid.NewGuid(), this.cache, null)
{
Parameter = parameter,
Owner = owner
};
var valueSet = new ParameterOverrideValueSet(Guid.NewGuid(), this.cache, null)
{
ParameterValueSet = parameterValueSet,
Published = new ValueArray <string>(new List <string> {
value
}),
Manual = new ValueArray <string>(new List <string> {
value
}),
Computed = new ValueArray <string>(new List <string> {
value
}),
Formula = new ValueArray <string>(new List <string> {
value
}),
ValueSwitch = ParameterSwitchKind.MANUAL
};
parameterOverride.ValueSet.Add(valueSet);
elementUsage.ParameterOverride.Add(parameterOverride);
}
public void VerifyThatParameterOverrideSubscriptionModelCodeReturnsExpectedResult()
{
var parameterOverride = new ParameterOverride();
this.elementUsage.ParameterOverride.Add(parameterOverride);
var parameterOverrideValueSet = new ParameterOverrideValueSet();
parameterOverride.ValueSet.Add(parameterOverrideValueSet);
parameterOverride.Parameter = this.parameter;
var subscription = new ParameterSubscription();
var subscriptionValueSet = new ParameterSubscriptionValueSet();
subscription.ValueSet.Add(subscriptionValueSet);
subscriptionValueSet.SubscribedValueSet = parameterOverrideValueSet;
parameterOverride.ParameterSubscription.Add(subscription);
Assert.AreEqual(@"Sat.battery_1.bool", subscriptionValueSet.ModelCode(0));
}
