public void VerifyThatOptionDependentStateDependentParameterValueSetReturnsExpectedModelCode() { var option = new Option(Guid.NewGuid(), null, null); option.ShortName = "option_1"; this.parameter.IsOptionDependent = true; this.parameterValueSet.ActualOption = option; 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.parameter.StateDependence = actualFiniteStateList; this.parameterValueSet.ActualState = actualFiniteState; Assert.AreEqual(@"Sat.m\option_1\SM", this.parameterValueSet.ModelCode(0)); }
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 SetUp() { this.cache = new ConcurrentDictionary <CacheKey, Lazy <Thing> >(); this.possibleFiniteStateList_1 = new PossibleFiniteStateList(Guid.NewGuid(), this.cache, this.uri); this.possibleFiniteState_1_1 = new PossibleFiniteState(Guid.NewGuid(), this.cache, this.uri); this.possibleFiniteState_1_2 = new PossibleFiniteState(Guid.NewGuid(), this.cache, this.uri); this.possibleFiniteStateList_1.PossibleState.Add(this.possibleFiniteState_1_1); this.possibleFiniteStateList_1.PossibleState.Add(this.possibleFiniteState_1_2); this.possibleFiniteStateList_2 = new PossibleFiniteStateList(Guid.NewGuid(), this.cache, this.uri); this.possibleFiniteState_2_1 = new PossibleFiniteState(Guid.NewGuid(), this.cache, this.uri); this.possibleFiniteState_2_2 = new PossibleFiniteState(Guid.NewGuid(), this.cache, this.uri); this.possibleFiniteStateList_2.PossibleState.Add(this.possibleFiniteState_2_1); this.possibleFiniteStateList_2.PossibleState.Add(this.possibleFiniteState_2_2); this.actualFiniteStateList = new ActualFiniteStateList(Guid.NewGuid(), this.cache, this.uri); this.actualFiniteStateList.PossibleFiniteStateList.Insert(1, this.possibleFiniteStateList_1); this.actualFiniteState_1 = new ActualFiniteState(Guid.NewGuid(), this.cache, this.uri); this.actualFiniteState_1.PossibleState.Add(this.possibleFiniteState_1_1); this.actualFiniteState_2 = new ActualFiniteState(Guid.NewGuid(), this.cache, this.uri); this.actualFiniteState_2.PossibleState.Add(this.possibleFiniteState_1_2); this.actualFiniteState_3 = new ActualFiniteState(Guid.NewGuid(), this.cache, this.uri); this.actualFiniteState_3.PossibleState.Add(this.possibleFiniteState_2_1); this.actualFiniteState_4 = new ActualFiniteState(Guid.NewGuid(), this.cache, this.uri); this.actualFiniteState_4.PossibleState.Add(this.possibleFiniteState_2_2); this.actualFiniteStateList.ActualState.Add(this.actualFiniteState_1); this.actualFiniteStateList.ActualState.Add(this.actualFiniteState_2); this.actualFiniteStateList.ActualState.Add(this.actualFiniteState_3); this.actualFiniteStateList.ActualState.Add(this.actualFiniteState_4); this.comparer = new ActualFiniteStateComparer(); }
public void VerifyThatGetPathWorks() { // **************************INPUT*************************************** var published = new ValueArray <string>(new List <string> { "manual1", "manual2" }, this.valueset); var actual = new ValueArray <string>(new List <string> { "manual1", "manual2" }, this.valueset); this.valueset.Published = published; this.valueset.Manual = actual; this.valueset.ValueSwitch = ParameterSwitchKind.MANUAL; this.valueset.ActualOption = this.option; var compoundtype = new CompoundParameterType(Guid.NewGuid(), null, this.uri); var component1 = new ParameterTypeComponent(Guid.NewGuid(), null, this.uri) { ParameterType = this.parameterType1, ShortName = "c1" }; var component2 = new ParameterTypeComponent(Guid.NewGuid(), null, this.uri) { ParameterType = this.parameterType1, ShortName = "c2" }; compoundtype.Component.Add(component1); compoundtype.Component.Add(component2); var state2 = new ActualFiniteState(Guid.NewGuid(), null, this.uri); this.stateList.ActualState.Add(state2); this.parameter1.ParameterType = compoundtype; this.parameter1.ValueSet.Add(this.valueset); this.parameter1.IsOptionDependent = true; var valueset2 = new ParameterValueSet(Guid.NewGuid(), null, this.uri) { ActualState = state2, Published = published }; this.parameter1.ValueSet.Add(valueset2); var row = new ParameterRowViewModel(this.parameter1, this.option, this.session.Object, null); Assert.AreEqual(this.nestedParameterPath, row.GetPath()); var row2 = new ParameterTypeComponentRowViewModel(compoundtype.Component.First(), this.session.Object, null); Assert.AreEqual(string.Empty, row2.GetPath()); var row3 = new ParameterTypeComponentRowViewModel(compoundtype.Component.First(), this.session.Object, row); Assert.AreEqual(this.nestedParameterPath, row3.GetPath()); }
public void Setup() { var ensurePackSchemeIsKnown = System.IO.Packaging.PackUriHelper.UriSchemePack; this.session = new Mock <ISession>(); this.cache = new ConcurrentDictionary <CacheKey, Lazy <Thing> >(); this.domain = new DomainOfExpertise(Guid.NewGuid(), this.cache, this.uri) { Name = "domain", ShortName = "dom" }; this.siteDirectory = new SiteDirectory(Guid.NewGuid(), this.cache, this.uri); this.model = new EngineeringModel(Guid.NewGuid(), this.cache, this.uri); this.modelSetup = new EngineeringModelSetup(Guid.NewGuid(), this.cache, this.uri); this.iteration = new Iteration(Guid.NewGuid(), this.cache, this.uri); this.iterationSetup = new IterationSetup(Guid.NewGuid(), this.cache, this.uri); this.person = new Person(Guid.NewGuid(), this.cache, this.uri) { GivenName = "test", Surname = "test" }; this.participant = new Participant(Guid.NewGuid(), this.cache, this.uri) { Person = this.person }; this.option = new Option(Guid.NewGuid(), this.cache, this.uri); this.elementdef1 = new ElementDefinition(Guid.NewGuid(), this.cache, this.uri); this.siteDirectory.Model.Add(this.modelSetup); this.modelSetup.IterationSetup.Add(this.iterationSetup); this.modelSetup.Participant.Add(this.participant); this.siteDirectory.Person.Add(this.person); this.model.Iteration.Add(this.iteration); this.model.EngineeringModelSetup = this.modelSetup; this.iteration.IterationSetup = this.iterationSetup; this.iteration.Option.Add(this.option); this.iteration.Element.Add(this.elementdef1); this.parameterType1 = new EnumerationParameterType(Guid.NewGuid(), this.cache, this.uri) { Name = "pt1" }; this.parameter1 = new Parameter(Guid.NewGuid(), this.cache, this.uri) { ParameterType = this.parameterType1, Owner = this.domain }; this.stateList = new ActualFiniteStateList(Guid.NewGuid(), this.cache, this.uri) { Owner = this.domain }; this.state1 = new ActualFiniteState(Guid.NewGuid(), this.cache, this.uri); this.valueset = new ParameterValueSet(Guid.NewGuid(), this.cache, this.uri); this.stateList.ActualState.Add(this.state1); this.elementdef1.Parameter.Add(this.parameter1); this.session.Setup(x => x.ActivePerson).Returns(this.person); this.session.Setup(x => x.OpenIterations).Returns(new Dictionary <Iteration, Tuple <DomainOfExpertise, Participant> >()); this.cache.TryAdd(new CacheKey(this.parameter1.Iid, null), new Lazy <Thing>(() => this.parameter1)); this.converter = new ProductTreeIconUriConverter(); }
public void VerifyThatTreeIsCorrectlyBuilt() { var possibleFiniteStateList = new PossibleFiniteStateList(Guid.NewGuid(), this.cache, this.uri); this.iteration.PossibleFiniteStateList.Add(possibleFiniteStateList); var possibleFiniteState = new PossibleFiniteState(Guid.NewGuid(), this.cache, this.uri); possibleFiniteStateList.PossibleState.Add(possibleFiniteState); var actualFiniteStateList = new ActualFiniteStateList(Guid.NewGuid(), this.cache, this.uri); actualFiniteStateList.PossibleFiniteStateList.Add(possibleFiniteStateList); this.iteration.ActualFiniteStateList.Add(actualFiniteStateList); var row = new ActualFiniteStateListRowViewModel(actualFiniteStateList, this.session.Object, null); Assert.IsEmpty(row.ContainedRows); var state = new ActualFiniteState(Guid.NewGuid(), this.cache, this.uri); state.PossibleState.Add(possibleFiniteState); actualFiniteStateList.ActualState.Add(state); this.rev.SetValue(actualFiniteStateList, 2); CDPMessageBus.Current.SendObjectChangeEvent(actualFiniteStateList, EventKind.Updated); var staterow = (ActualFiniteStateRowViewModel)row.ContainedRows.SingleOrDefault(); Assert.IsNotNull(staterow); }
public void Verify_that_ExecuteBatchUpdateParameterCommand_works_as_expected() { var possibleList = new PossibleFiniteStateList(Guid.NewGuid(), this.cache, this.uri); var ps = new PossibleFiniteState(Guid.NewGuid(), this.cache, this.uri); possibleList.PossibleState.Add(ps); this.iteration.PossibleFiniteStateList.Add(possibleList); var actualList = new ActualFiniteStateList(Guid.NewGuid(), this.cache, this.uri); actualList.PossibleFiniteStateList.Add(possibleList); var astate = new ActualFiniteState(Guid.NewGuid(), this.cache, this.uri); astate.PossibleState.Add(ps); actualList.ActualState.Add(astate); this.iteration.ActualFiniteStateList.Add(actualList); var dialogResult = new CDP4EngineeringModel.ViewModels.Dialogs.CategoryDomainParameterTypeSelectorResult(true, false, Enumerable.Empty <ParameterType>(), Enumerable.Empty <Category>(), Enumerable.Empty <DomainOfExpertise>()); this.dialogNavigationService.Setup(x => x.NavigateModal(It.IsAny <IDialogViewModel>())).Returns(dialogResult); var vm = new FiniteStateBrowserViewModel(this.iteration, this.session.Object, null, null, this.dialogNavigationService.Object, null, this.parameterActualFiniteStateListApplicationBatchService.Object); vm.SelectedThing = new ActualFiniteStateListRowViewModel(actualList, this.session.Object, null); vm.BatchUpdateParameterCommand.Execute(null); this.dialogNavigationService.Verify(x => x.NavigateModal(It.IsAny <IDialogViewModel>()), Times.Exactly(1)); this.parameterActualFiniteStateListApplicationBatchService.Verify(x => x.Update(this.session.Object, this.iteration, It.IsAny <ActualFiniteStateList>(), false, It.IsAny <IEnumerable <Category> >(), It.IsAny <IEnumerable <DomainOfExpertise> >(), It.IsAny <IEnumerable <ParameterType> >()), Times.Exactly(1)); }
/// <summary> /// Gets the <see cref="ParameterValueSetBase"/> for an <see cref="Option"/> (if this <see cref="ParameterOrOverrideBase"/> is option dependent) and a <see cref="ActualFiniteState"/> (if it is state dependent) /// </summary> /// <param name="actualState">The <see cref="ActualFiniteState"/></param> /// <param name="actualOption">The <see cref="Option"/></param> /// <returns>The <see cref="ParameterValueSetBase"/> if a value is defined for the <see cref="Option"/></returns> protected override ParameterValueSetBase GetValueSet(ActualFiniteState actualState = null, Option actualOption = null) { var isStateDependent = this.StateDependence != null; var parameterOverride = (ParameterOverride)this.Thing; var valueset = parameterOverride.ValueSet.SingleOrDefault(x => (!isStateDependent || x.ActualState == actualState) && (!this.IsOptionDependent || x.ActualOption == actualOption)); return(valueset); }
public void VerifyThatNullContainerThrowException3() { this.actualFiniteState = new ActualFiniteState(Guid.NewGuid(), null, null); Assert.Throws <ContainmentException>(() => { Console.WriteLine(this.actualFiniteState.Owner); }); }
/// <summary> /// Initializes a new instance of the <see cref="ParameterStateRowViewModel"/> class /// </summary> /// <param name="parameterBase">The associated value-set of a <see cref="ParameterBase"/></param> /// <param name="actualFiniteState">The <see cref="ActualFiniteState"/> represented</param> /// <param name="session">The <see cref="ISession"/></param> /// <param name="containerViewModel">The container <see cref="IViewModelBase{T}"/></param> public ParameterStateRowViewModel(ParameterBase parameterBase, ActualFiniteState actualFiniteState, ISession session, IViewModelBase <Thing> containerViewModel) : base(parameterBase, session, containerViewModel) { this.IsPublishable = false; this.ActualState = actualFiniteState; this.IsDefault = this.ActualState.IsDefault; this.Name = this.ActualState.Name; }
public void VerifyUpdatePropertiesBasedOnMappingConfiguration() { var elementDefinition = new ElementDefinition(Guid.NewGuid(), null, null); this.hubController.Setup(x => x.GetThingById(It.IsAny <Guid>(), It.IsAny <Iteration>(), out elementDefinition)).Returns(true); var parameter = new Parameter(Guid.NewGuid(), null, null); this.hubController.Setup(x => x.GetThingById(It.IsAny <Guid>(), It.IsAny <Iteration>(), out parameter)).Returns(true); var option = new Option(Guid.NewGuid(), null, null); this.hubController.Setup(x => x.GetThingById(It.IsAny <Guid>(), It.IsAny <Iteration>(), out option)).Returns(true); var state = new ActualFiniteState(Guid.NewGuid(), null, null); this.hubController.Setup(x => x.GetThingById(It.IsAny <Guid>(), It.IsAny <Iteration>(), out state)).Returns(true); var elementUsage = new ElementUsage(Guid.NewGuid(), null, null); this.hubController.Setup(x => x.GetThingById(It.IsAny <Guid>(), It.IsAny <Iteration>(), out elementUsage)).Returns(true); var correspondences = new List <IdCorrespondence> { new IdCorrespondence() { ExternalId = "trans0", InternalThing = elementDefinition.Iid }, new IdCorrespondence() { ExternalId = "res0", InternalThing = parameter.Iid }, new IdCorrespondence() { ExternalId = "trans0", InternalThing = option.Iid }, new IdCorrespondence() { ExternalId = "trans0", InternalThing = state.Iid }, new IdCorrespondence() { ExternalId = "res0", InternalThing = elementUsage.Iid }, }; foreach (var variable in this.viewModel.Variables) { variable.MappingConfigurations.AddRange( correspondences.Where( x => x.ExternalId == variable.ElementName || x.ExternalId == variable.ParameterName)); } Assert.DoesNotThrow(() => this.viewModel.UpdatePropertiesBasedOnMappingConfiguration()); this.hubController.Verify(x => x.GetThingById(It.IsAny <Guid>(), It.IsAny <Iteration>(), out It.Ref <Thing> .IsAny), Times.Exactly(5)); }
public void Verify_that_when_containers_are_not_the_same_exception_is_thrown() { var otherActualFiniteStateList = new ActualFiniteStateList(Guid.NewGuid(), this.cache, this.uri); var otherActualFiniteState = new ActualFiniteState(Guid.NewGuid(), this.cache, this.uri); otherActualFiniteStateList.ActualState.Add(otherActualFiniteState); Assert.Throws <InvalidOperationException>(() => this.comparer.Compare(this.actualFiniteState_1, otherActualFiniteState)); }
/// <summary> /// Initializes a new instance of the <see cref="ParameterValueBaseRowViewModel"/> class /// </summary> /// <param name="parameterBase"> /// The associated <see cref="ParameterBase"/> /// </param> /// <param name="session"> /// The <see cref="ISession"/> /// </param> /// <param name="actualOption"> /// The actual <see cref="Option"/> represented if any /// </param> /// <param name="actualState"> /// The actual <see cref="ActualFiniteState"/> represented if any /// </param> /// <param name="containerRow"> /// The row container /// </param> /// <param name="valueIndex"> /// The index of the component if applicable /// </param> /// <param name="isReadOnly"> /// A value indicating whether the row is read-only /// </param> protected ParameterValueBaseRowViewModel(ParameterBase parameterBase, ISession session, Option actualOption, ActualFiniteState actualState, IViewModelBase <Thing> containerRow, int valueIndex = 0, bool isReadOnly = false) : base(parameterBase, session, containerRow) { this.isParameterBaseReadOnlyInDataContext = isReadOnly; this.ActualOption = actualOption; this.ActualState = actualState; this.ValueIndex = valueIndex; this.ParameterTypeClassKind = this.Thing.ParameterType.ClassKind; this.SetOwnerValue(); }
private void SetupFiniteStates() { this.ActualPossibleFiniteStateList = new ActualFiniteStateList(Guid.NewGuid(), this.Assembler.Cache, this.uri); var possibleStateList = new PossibleFiniteStateList(Guid.NewGuid(), this.Assembler.Cache, this.uri) { ShortName = "actualFiniteStateListTest" }; var possibleState1 = new PossibleFiniteState(Guid.NewGuid(), this.Assembler.Cache, this.uri) { Name = "1" }; var possibleState2 = new PossibleFiniteState(Guid.NewGuid(), this.Assembler.Cache, this.uri) { Name = "2" }; var possibleState3 = new PossibleFiniteState(Guid.NewGuid(), this.Assembler.Cache, this.uri) { Name = "3" }; possibleStateList.PossibleState.Add(possibleState1); possibleStateList.PossibleState.Add(possibleState2); possibleStateList.PossibleState.Add(possibleState3); this.Iteration.PossibleFiniteStateList.Add(possibleStateList); this.ActualPossibleFiniteStateList = new ActualFiniteStateList(Guid.NewGuid(), this.Assembler.Cache, this.uri); var actualState1 = new ActualFiniteState(Guid.NewGuid(), this.Assembler.Cache, this.uri) { PossibleState = new List <PossibleFiniteState> { possibleState1 } }; var actualState2 = new ActualFiniteState(Guid.NewGuid(), this.Assembler.Cache, this.uri) { PossibleState = new List <PossibleFiniteState> { possibleState2 } }; var actualState3 = new ActualFiniteState(Guid.NewGuid(), this.Assembler.Cache, this.uri) { PossibleState = new List <PossibleFiniteState> { possibleState3 } }; this.ActualPossibleFiniteStateList.ActualState.Add(actualState1); this.ActualPossibleFiniteStateList.ActualState.Add(actualState2); this.ActualPossibleFiniteStateList.ActualState.Add(actualState3); this.ActualPossibleFiniteStateList.PossibleFiniteStateList.Add(possibleStateList); this.Iteration.ActualFiniteStateList.Add(this.ActualPossibleFiniteStateList); }
/// <summary> /// Initializes a new instance of the <see cref="ActualFiniteStateRowViewModel"/> class /// </summary> /// <param name="actualFiniteState">The <see cref="ActualFiniteState"/> represented</param> /// <param name="session">The <see cref="ISession"/></param> /// <param name="containerViewModel">The container <see cref="IViewModelBase{T}"/></param> public ActualFiniteStateRowViewModel(ActualFiniteState actualFiniteState, ISession session, IViewModelBase <Thing> containerViewModel) : base(actualFiniteState, session, containerViewModel) { this.IsPublishable = false; var parameterOrOverrideBaseRowViewModel = containerViewModel as ParameterOrOverrideBaseRowViewModel; if (parameterOrOverrideBaseRowViewModel != null) { this.OwnerShortName = parameterOrOverrideBaseRowViewModel.OwnerShortName; } }
/// <summary> /// Creates a new instance of the <see cref="ParameterToStateMapping"/> class /// </summary> /// <param name="value">The value</param> /// <param name="parameterType">The <see cref="ParameterType"/> that was mapped</param> /// <param name="actualFiniteState">The <see cref="ActualFiniteState"/></param> /// <param name="shortName">ShortName to add to the mapping</param> public ParameterToStateMapping(string value, ParameterType parameterType, ActualFiniteState actualFiniteState, string shortName) { this.ParameterTypeIid = parameterType.Iid; this.ParameterTypeName = parameterType.Name; this.ParameterTypeShortName = parameterType.ShortName; this.ActualFiniteStateIid = actualFiniteState.Iid; this.ActualFiniteStateShortName = actualFiniteState.ShortName; this.ActualFiniteStateName = actualFiniteState.Name; this.Value = value; this.ShortName = shortName; }
public void VerifyThatContainerSetToClone() { var list = new ActualFiniteStateList(); var state = new ActualFiniteState(); list.ActualState.Add(state); var clone = list.Clone(false); Assert.AreSame(list, state.Container); clone.ActualState.Clear(); clone.ActualState.Add(state); Assert.AreSame(clone, state.Container); }
/// <summary> /// Serialize the <see cref="ActualFiniteState"/> /// </summary> /// <param name="actualFiniteState">The <see cref="ActualFiniteState"/> to serialize</param> /// <returns>The <see cref="JObject"/></returns> private JObject Serialize(ActualFiniteState actualFiniteState) { var jsonObject = new JObject(); jsonObject.Add("classKind", this.PropertySerializerMap["classKind"](Enum.GetName(typeof(CDP4Common.CommonData.ClassKind), actualFiniteState.ClassKind))); jsonObject.Add("excludedDomain", this.PropertySerializerMap["excludedDomain"](actualFiniteState.ExcludedDomain.OrderBy(x => x, this.guidComparer))); jsonObject.Add("excludedPerson", this.PropertySerializerMap["excludedPerson"](actualFiniteState.ExcludedPerson.OrderBy(x => x, this.guidComparer))); jsonObject.Add("iid", this.PropertySerializerMap["iid"](actualFiniteState.Iid)); jsonObject.Add("kind", this.PropertySerializerMap["kind"](Enum.GetName(typeof(CDP4Common.EngineeringModelData.ActualFiniteStateKind), actualFiniteState.Kind))); jsonObject.Add("modifiedOn", this.PropertySerializerMap["modifiedOn"](actualFiniteState.ModifiedOn)); jsonObject.Add("possibleState", this.PropertySerializerMap["possibleState"](actualFiniteState.PossibleState.OrderBy(x => x, this.guidComparer))); jsonObject.Add("revisionNumber", this.PropertySerializerMap["revisionNumber"](actualFiniteState.RevisionNumber)); jsonObject.Add("thingPreference", this.PropertySerializerMap["thingPreference"](actualFiniteState.ThingPreference)); return(jsonObject); }
/// <summary> /// Initializes a new instance of the <see cref="ParameterStateRowViewModel"/> class /// </summary> /// <param name="parameterBase">The associated value-set of a <see cref="ParameterBase"/></param> /// <param name="actualFiniteState">The <see cref="ActualFiniteState"/> represented</param> /// <param name="session">The <see cref="ISession"/></param> /// <param name="containerViewModel">The container <see cref="IViewModelBase{T}"/></param> public ParameterStateRowViewModel(ParameterBase parameterBase, ActualFiniteState actualFiniteState, ISession session, IViewModelBase <Thing> containerViewModel) : base(parameterBase, session, containerViewModel) { this.IsPublishable = false; this.ActualState = actualFiniteState; this.IsDefault = this.ActualState.IsDefault; this.Name = this.ActualState.Name; if (containerViewModel is ParameterOrOverrideBaseRowViewModel parameterOrOverrideBaseRowViewModel) { this.Option = parameterOrOverrideBaseRowViewModel.Option; } this.InitializeOptionSubscriptions(); }
public void VerifyThatContextMenuPopulated() { this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true); this.permissionService.Setup(x => x.CanWrite(It.IsAny <Thing>())).Returns(true); var possibleList = new PossibleFiniteStateList(Guid.NewGuid(), this.cache, this.uri); var ps = new PossibleFiniteState(Guid.NewGuid(), this.cache, this.uri); possibleList.PossibleState.Add(ps); this.iteration.PossibleFiniteStateList.Add(possibleList); var actualList = new ActualFiniteStateList(Guid.NewGuid(), this.cache, this.uri); actualList.PossibleFiniteStateList.Add(possibleList); var astate = new ActualFiniteState(Guid.NewGuid(), this.cache, this.uri); astate.PossibleState.Add(ps); actualList.ActualState.Add(astate); this.iteration.ActualFiniteStateList.Add(actualList); var viewmodel = new FiniteStateBrowserViewModel(this.iteration, this.session.Object, this.thingDialogNavigationService.Object, this.panelNavigationService.Object, null, null); // no row selected viewmodel.ComputePermission(); viewmodel.PopulateContextMenu(); Assert.AreEqual(2, viewmodel.ContextMenu.Count); // posible state row selected var pslFolder = viewmodel.FiniteStateList.First(); var psRow = pslFolder.ContainedRows.First().ContainedRows.First(); viewmodel.SelectedThing = psRow; viewmodel.ComputePermission(); viewmodel.PopulateContextMenu(); Assert.AreEqual(8, viewmodel.ContextMenu.Count); // execute set default Assert.IsTrue(viewmodel.CanSetAsDefault); viewmodel.SetDefaultStateCommand.Execute(null); this.session.Verify(x => x.Write(It.IsAny <OperationContainer>())); }
/// <summary> /// Compare the two instances of <see cref="ActualFiniteState "/> /// </summary> /// <param name="x"> /// the first instance of <see cref="ActualFiniteState"/> to compare. /// </param> /// <param name="y"> /// the second instance of <see cref="ActualFiniteState"/> to compare. /// </param> /// <returns> /// Less than zero : x is less than y. /// Zero: x equals y. /// Greater than zero: x is greater than y. /// </returns> /// <remarks> /// the order is determined by the ordering in the container collection /// </remarks> private static int CompareActualState(ActualFiniteState x, ActualFiniteState y) { if (x == null && y == null) { return(0); } if (x == null && y != null) { return(1); } if (x != null && y == null) { return(-1); } var actualFiniteStateListX = (ActualFiniteStateList)x.Container; var actualFiniteStateListY = (ActualFiniteStateList)y.Container; if (actualFiniteStateListX != actualFiniteStateListY) { throw new InvalidOperationException("The ActualFiniteStates are not contained by the same ActualFiniteStateList and cannot be compared"); } var indexX = actualFiniteStateListX.ActualState.IndexOf(x); var indexY = actualFiniteStateListY.ActualState.IndexOf(y); if (indexX < indexY) { return(-1); } if (indexX == indexY) { return(0); } if (indexX > indexY) { return(1); } return(0); }
/// <summary> /// Initializes a new instance of the <see cref="ParameterValueBaseRowViewModel"/> class /// </summary> /// <param name="parameterBase"> /// The associated <see cref="ParameterBase"/> /// </param> /// <param name="session"> /// The <see cref="ISession"/> /// </param> /// <param name="actualOption"> /// The actual <see cref="Option"/> represented if any /// </param> /// <param name="actualState"> /// The actual <see cref="ActualFiniteState"/> represented if any /// </param> /// <param name="containerRow"> /// The row container /// </param> /// <param name="valueIndex"> /// The index of the component if applicable /// </param> /// <param name="isDialogReadOnly"> /// Value indicating whether this row should be read-only because the dialog is read-only /// </param> protected ParameterValueBaseRowViewModel(ParameterBase parameterBase, ISession session, Option actualOption, ActualFiniteState actualState, IViewModelBase <Thing> containerRow, int valueIndex = 0, bool isDialogReadOnly = false) : base(parameterBase, session, containerRow) { this.ActualOption = actualOption; this.ActualState = actualState; this.ValueIndex = valueIndex; this.ParameterTypeClassKind = this.ParameterType.ClassKind; this.WhenAnyValue(vm => vm.Switch).Skip(1).Subscribe(_ => this.UpdateActualValue()); this.WhenAnyValue(vm => vm.Manual).Skip(1).Subscribe(_ => this.UpdateActualValue()); this.WhenAnyValue(vm => vm.Computed).Skip(1).Subscribe(_ => this.UpdateActualValue()); this.WhenAnyValue(vm => vm.Reference).Skip(1).Subscribe(_ => this.UpdateActualValue()); var option = this.ActualOption == null ? string.Empty : this.ActualOption.ShortName; var state = this.ActualState == null ? string.Empty : this.ActualState.ShortName; this.RowCode = string.Format("{0}.{1}.{2}", option, state, this.ValueIndex); this.DialogViewModel = (IDialogViewModelBase <ParameterBase>) this.TopContainerViewModel; var subscription = this.Thing as ParameterSubscription; if (subscription != null) { var parameter = (ParameterOrOverrideBase)subscription.Container; if (parameter.Owner != null) { this.OwnerName = "[" + parameter.Owner.Name + "]"; this.OwnerShortName = "[" + parameter.Owner.ShortName + "]"; } } else { if (this.Owner != null) { this.OwnerName = this.Owner.Name; this.OwnerShortName = this.Owner.ShortName; } } }
public void VerifyThatStateDependentParameterValueSetReturnsExpectedModelCode() { 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.parameter.StateDependence = actualFiniteStateList; this.parameterValueSet.ActualState = actualFiniteState; Assert.AreEqual(@"Sat.m\SM", this.parameterValueSet.ModelCode(0)); }
public void SetUp() { this.iteration = new Iteration(Guid.NewGuid(), null, null); this.optiona = new Option(Guid.NewGuid(), null, null) { Name = "option a", ShortName = "optionb" }; this.optionb = new Option(Guid.NewGuid(), null, null) { Name = "option b", ShortName = "optionb" }; this.iteration.Option.Add(this.optionb); this.iteration.Option.Add(this.optiona); var possibleFiniteStateList = new PossibleFiniteStateList(Guid.NewGuid(), null, null); var possibleFiniteStatea = new PossibleFiniteState(Guid.NewGuid(), null, null) { Name = "state a", ShortName = "statea" }; var possibleFiniteStateb = new PossibleFiniteState(Guid.NewGuid(), null, null) { Name = "state b", ShortName = "stateb" }; possibleFiniteStateList.PossibleState.Add(possibleFiniteStateb); possibleFiniteStateList.PossibleState.Add(possibleFiniteStatea); this.iteration.PossibleFiniteStateList.Add(possibleFiniteStateList); var actualFiniteStateList = new ActualFiniteStateList(Guid.NewGuid(), null, null); this.actualFiniteStatea = new ActualFiniteState(Guid.NewGuid(), null, null); this.actualFiniteStatea.PossibleState.Add(possibleFiniteStatea); this.actualFiniteStateb = new ActualFiniteState(Guid.NewGuid(), null, null); this.actualFiniteStateb.PossibleState.Add(possibleFiniteStateb); actualFiniteStateList.ActualState.Add(this.actualFiniteStateb); actualFiniteStateList.ActualState.Add(this.actualFiniteStatea); this.iteration.ActualFiniteStateList.Add(actualFiniteStateList); }
/// <summary> /// Creates and returns a new parameter value set for the given option and state /// </summary> /// <param name="option"> /// The option. /// </param> /// <param name="state"> /// The state. /// </param> /// <returns> /// The <see cref="ParameterValueSet"/>. /// </returns> private ParameterValueSet GetNewParameterValueSet(Option option, ActualFiniteState state) { return(new ParameterValueSet(Guid.NewGuid(), null, this.uri) { ActualOption = option, ActualState = state, Computed = new ValueArray <string>(new List <string> { "-" }), Manual = new ValueArray <string>(new List <string> { "-" }), Reference = new ValueArray <string>(new List <string> { "-" }), Formula = new ValueArray <string>(new List <string> { "-" }), Published = new ValueArray <string>(new List <string> { "-" }), ValueSwitch = ParameterSwitchKind.COMPUTED }); }
public void Setup() { this.actualFiniteState = new ActualFiniteState(Guid.NewGuid(), null, null); this.actualList = new ActualFiniteStateList(Guid.NewGuid(), null, null); this.actualList.Owner = new DomainOfExpertise(Guid.NewGuid(), null, null); this.possibleList1 = new PossibleFiniteStateList(Guid.NewGuid(), null, null); this.possibleList2 = new PossibleFiniteStateList(Guid.NewGuid(), null, null); this.possibleState1 = new PossibleFiniteState(Guid.NewGuid(), null, null) { Name = "possiblestate1", ShortName = "1" }; this.possibleState2 = new PossibleFiniteState(Guid.NewGuid(), null, null) { Name = "possiblestate2", ShortName = "2" }; this.possibleList1.PossibleState.Add(this.possibleState1); this.possibleList2.PossibleState.Add(this.possibleState2); this.actualFiniteState.PossibleState.Add(this.possibleState1); this.actualFiniteState.PossibleState.Add(this.possibleState2); this.actualList.PossibleFiniteStateList.Add(this.possibleList1); this.actualList.PossibleFiniteStateList.Add(this.possibleList2); this.iteration = new Iteration(Guid.NewGuid(), null, null); this.model = new EngineeringModel(Guid.NewGuid(), null, null); this.model.Iteration.Add(this.iteration); this.iteration.ActualFiniteStateList.Add(this.actualList); this.iteration.PossibleFiniteStateList.Add(this.possibleList1); this.iteration.PossibleFiniteStateList.Add(this.possibleList2); this.actualList.ActualState.Add(this.actualFiniteState); }
/// <summary> /// Gets the actual float value associated to the <paramref name="pt"/> for a <see cref="ElementUsage"/> /// </summary> /// <param name="usage">The <see cref="ElementUsage"/></param> /// <param name="pt">The <see cref="QuantityKind"/></param> /// <param name="state">The state</param> /// <param name="option">The value associated to the option to get</param> /// <param name="domain">The current domain</param> /// <returns>The converted float value</returns> public static float?GetFloatActualValue(this ElementUsage usage, QuantityKind pt, ActualFiniteState state, Option option, DomainOfExpertise domain) { var value = GetActualValue(usage, pt, state, option, domain); float converted; if (float.TryParse(value, out converted)) { return(converted); } return(null); }
/// <summary> /// Gets the actual value associated to the <paramref name="pt"/> for a <see cref="ElementUsage"/> /// </summary> /// <param name="usage">The <see cref="ElementUsage"/></param> /// <param name="pt">The <see cref="ParameterType"/></param> /// <param name="state">The state</param> /// <param name="option">The value associated to the option to get</param> /// <param name="domain">The current domain</param> /// <returns>The value</returns> public static string GetActualValue(this ElementUsage usage, ParameterType pt, ActualFiniteState state, Option option, DomainOfExpertise domain) { var parameterOrOverride = (ParameterOrOverrideBase)usage.ParameterOverride.FirstOrDefault(x => x.ParameterType.Iid.Equals(pt.Iid)) ?? usage.ElementDefinition.Parameter.FirstOrDefault(x => x.ParameterType.Iid.Equals(pt.Iid)); if (parameterOrOverride == null) { // no value found associated to the parameter-type return(null); } var parameterBase = (ParameterBase)parameterOrOverride.ParameterSubscription.FirstOrDefault(x => x.Owner.Iid.Equals(domain?.Iid)) ?? parameterOrOverride; var valueset = parameterBase.ValueSets.FirstOrDefault(x => (x.ActualOption == null || x.ActualOption.Iid.Equals(option.Iid)) && (x.ActualState == null || x.ActualState.Iid.Equals(state?.Iid))); return(valueset?.ActualValue.FirstOrDefault()); }
public void Setup() { this.permissionService = new Mock <IPermissionService>(); this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true); this.thingDialognavigationService = new Mock <IThingDialogNavigationService>(); this.session = new Mock <ISession>(); this.session.Setup(x => x.PermissionService).Returns(this.permissionService.Object); this.stateList = new ActualFiniteStateList(Guid.NewGuid(), null, this.uri); this.state1 = new PossibleFiniteState(Guid.NewGuid(), null, this.uri) { Name = "state1" }; this.state2 = new PossibleFiniteState(Guid.NewGuid(), null, this.uri) { Name = "state2" }; this.posStateList = new PossibleFiniteStateList(Guid.NewGuid(), null, this.uri); this.posStateList.PossibleState.Add(this.state1); this.posStateList.PossibleState.Add(this.state2); this.posStateList.DefaultState = this.state1; this.actualState1 = new ActualFiniteState(Guid.NewGuid(), null, this.uri) { PossibleState = new List <PossibleFiniteState> { this.state1 }, Kind = ActualFiniteStateKind.MANDATORY }; this.actualState2 = new ActualFiniteState(Guid.NewGuid(), null, this.uri) { PossibleState = new List <PossibleFiniteState> { this.state2 }, Kind = ActualFiniteStateKind.MANDATORY }; this.stateList.ActualState.Add(this.actualState1); this.stateList.ActualState.Add(this.actualState2); this.stateList.PossibleFiniteStateList.Add(this.posStateList); this.option1 = new Option(Guid.NewGuid(), null, this.uri) { Name = "option1" }; this.option2 = new Option(Guid.NewGuid(), null, this.uri) { Name = "option2" }; this.qqParamType = new SimpleQuantityKind(Guid.NewGuid(), null, this.uri) { Name = "PTName", ShortName = "PTShortName" }; this.enum1 = new EnumerationValueDefinition(Guid.NewGuid(), null, this.uri) { Name = "enum1" }; this.enum2 = new EnumerationValueDefinition(Guid.NewGuid(), null, this.uri) { Name = "enum2" }; this.enumPt = new EnumerationParameterType(Guid.NewGuid(), null, this.uri); this.enumPt.ValueDefinition.Add(this.enum1); this.enumPt.ValueDefinition.Add(this.enum2); this.cptType = new CompoundParameterType(Guid.NewGuid(), null, this.uri) { Name = "APTName", ShortName = "APTShortName" }; this.cptType.Component.Add(new ParameterTypeComponent(Guid.NewGuid(), null, this.uri) { Iid = Guid.NewGuid(), ParameterType = this.qqParamType, ShortName = "c1" }); this.cptType.Component.Add(new ParameterTypeComponent(Guid.NewGuid(), null, this.uri) { Iid = Guid.NewGuid(), ParameterType = this.enumPt, ShortName = "c2" }); this.activeDomain = new DomainOfExpertise(Guid.NewGuid(), null, this.uri) { Name = "active", ShortName = "active" }; this.someotherDomain = new DomainOfExpertise(Guid.NewGuid(), null, this.uri) { Name = "other", ShortName = "other" }; this.parameter = new Parameter(Guid.NewGuid(), null, this.uri) { Owner = this.activeDomain, ParameterType = this.qqParamType }; this.cptParameter = new Parameter(Guid.NewGuid(), null, this.uri) { Owner = this.activeDomain, ParameterType = this.cptType, IsOptionDependent = true, StateDependence = this.stateList }; this.cptParameter.ValueSet.Add(this.GetNewParameterValueSet(this.option1, this.stateList.ActualState.First())); this.cptParameter.ValueSet.Add(this.GetNewParameterValueSet(this.option1, this.stateList.ActualState.Last())); this.cptParameter.ValueSet.Add(this.GetNewParameterValueSet(this.option2, this.stateList.ActualState.First())); this.cptParameter.ValueSet.Add(this.GetNewParameterValueSet(this.option2, this.stateList.ActualState.Last())); this.elementDefinition = new ElementDefinition(Guid.NewGuid(), null, this.uri) { Owner = this.activeDomain }; this.elementDefinitionForUsage1 = new ElementDefinition(Guid.NewGuid(), null, this.uri); this.elementUsage1 = new ElementUsage(Guid.NewGuid(), null, this.uri) { ElementDefinition = this.elementDefinitionForUsage1 }; this.elementDefinition.ContainedElement.Add(this.elementUsage1); this.elementDefinitionForUsage1.Parameter.Add(this.parameter); this.elementDefinitionForUsage1.Parameter.Add(this.cptParameter); this.iteration = new Iteration(Guid.NewGuid(), null, this.uri); this.iteration.Element.Add(this.elementDefinition); this.iteration.Element.Add(this.elementDefinitionForUsage1); this.iteration.Option.Add(this.option1); this.iteration.Option.Add(this.option2); this.model = new EngineeringModel(Guid.NewGuid(), null, this.uri); this.model.Iteration.Add(this.iteration); this.person = new Person(Guid.NewGuid(), null, this.uri) { GivenName = "test", Surname = "test" }; this.participant = new Participant(Guid.NewGuid(), null, this.uri) { Person = this.person, SelectedDomain = this.activeDomain }; this.session.Setup(x => x.ActivePerson).Returns(this.person); this.modelsetup = new EngineeringModelSetup(Guid.NewGuid(), null, this.uri); this.modelsetup.Participant.Add(this.participant); this.model.EngineeringModelSetup = this.modelsetup; this.session.Setup(x => x.PermissionService).Returns(this.permissionService.Object); this.permissionService.Setup(x => x.CanWrite(It.IsAny <Thing>())).Returns(true); this.assembler = new Assembler(this.uri); this.session.Setup(x => x.Assembler).Returns(this.assembler); this.session.Setup(x => x.OpenIterations).Returns(new Dictionary <Iteration, Tuple <DomainOfExpertise, Participant> >()); }
public void VerifyThatActualFiniteStateKindIsUpdatedOnNewDefault() { var model = new EngineeringModel(Guid.NewGuid(), this.assembler.Cache, this.uri); var iteration = new Iteration(Guid.NewGuid(), this.assembler.Cache, this.uri); var possibleList1 = new PossibleFiniteStateList(Guid.NewGuid(), this.assembler.Cache, this.uri); var possibleList2 = new PossibleFiniteStateList(Guid.NewGuid(), this.assembler.Cache, this.uri); var possibleList3 = new PossibleFiniteStateList(Guid.NewGuid(), this.assembler.Cache, this.uri); var ps11 = new PossibleFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); var ps12 = new PossibleFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); var ps21 = new PossibleFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); var ps22 = new PossibleFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); var ps31 = new PossibleFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); var ps32 = new PossibleFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); possibleList1.PossibleState.Add(ps11); possibleList1.PossibleState.Add(ps12); possibleList2.PossibleState.Add(ps21); possibleList2.PossibleState.Add(ps22); possibleList3.PossibleState.Add(ps31); possibleList3.PossibleState.Add(ps32); var actualList1 = new ActualFiniteStateList(Guid.NewGuid(), this.assembler.Cache, this.uri); var actualList2 = new ActualFiniteStateList(Guid.NewGuid(), this.assembler.Cache, this.uri); actualList1.PossibleFiniteStateList.Add(possibleList1); actualList1.PossibleFiniteStateList.Add(possibleList2); var as11 = new ActualFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); as11.PossibleState.Add(ps11); as11.PossibleState.Add(ps21); var as12 = new ActualFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); as12.PossibleState.Add(ps11); as12.PossibleState.Add(ps22); var as13 = new ActualFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); as13.PossibleState.Add(ps12); as13.PossibleState.Add(ps21); var as14 = new ActualFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); as14.PossibleState.Add(ps12); as14.PossibleState.Add(ps22); actualList1.ActualState.Add(as11); actualList1.ActualState.Add(as12); actualList1.ActualState.Add(as13); actualList1.ActualState.Add(as14); actualList2.PossibleFiniteStateList.Add(possibleList2); actualList2.PossibleFiniteStateList.Add(possibleList3); var as21 = new ActualFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); as21.PossibleState.Add(ps21); as21.PossibleState.Add(ps31); var as22 = new ActualFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); as22.PossibleState.Add(ps21); as22.PossibleState.Add(ps32); var as23 = new ActualFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); as23.PossibleState.Add(ps22); as23.PossibleState.Add(ps31); var as24 = new ActualFiniteState(Guid.NewGuid(), this.assembler.Cache, this.uri); as24.PossibleState.Add(ps22); as24.PossibleState.Add(ps32); actualList2.ActualState.Add(as21); actualList2.ActualState.Add(as22); actualList2.ActualState.Add(as23); actualList2.ActualState.Add(as24); model.Iteration.Add(iteration); iteration.PossibleFiniteStateList.Add(possibleList1); iteration.PossibleFiniteStateList.Add(possibleList2); iteration.PossibleFiniteStateList.Add(possibleList3); iteration.ActualFiniteStateList.Add(actualList1); iteration.ActualFiniteStateList.Add(actualList2); this.assembler.Cache.TryAdd(new CacheKey(model.Iid, null), new Lazy <Thing>(() => model)); this.assembler.Cache.TryAdd(new CacheKey(iteration.Iid, null), new Lazy <Thing>(() => iteration)); this.assembler.Cache.TryAdd(new CacheKey(possibleList1.Iid, iteration.Iid), new Lazy <Thing>(() => possibleList1)); this.assembler.Cache.TryAdd(new CacheKey(possibleList2.Iid, iteration.Iid), new Lazy <Thing>(() => possibleList2)); this.assembler.Cache.TryAdd(new CacheKey(possibleList3.Iid, iteration.Iid), new Lazy <Thing>(() => possibleList3)); this.assembler.Cache.TryAdd(new CacheKey(ps11.Iid, iteration.Iid), new Lazy <Thing>(() => ps11)); this.assembler.Cache.TryAdd(new CacheKey(ps12.Iid, iteration.Iid), new Lazy <Thing>(() => ps12)); this.assembler.Cache.TryAdd(new CacheKey(ps21.Iid, iteration.Iid), new Lazy <Thing>(() => ps21)); this.assembler.Cache.TryAdd(new CacheKey(ps22.Iid, iteration.Iid), new Lazy <Thing>(() => ps22)); this.assembler.Cache.TryAdd(new CacheKey(ps31.Iid, iteration.Iid), new Lazy <Thing>(() => ps31)); this.assembler.Cache.TryAdd(new CacheKey(ps32.Iid, iteration.Iid), new Lazy <Thing>(() => ps32)); this.assembler.Cache.TryAdd(new CacheKey(actualList1.Iid, iteration.Iid), new Lazy <Thing>(() => actualList1)); this.assembler.Cache.TryAdd(new CacheKey(actualList2.Iid, iteration.Iid), new Lazy <Thing>(() => actualList2)); this.assembler.Cache.TryAdd(new CacheKey(as11.Iid, iteration.Iid), new Lazy <Thing>(() => as11)); this.assembler.Cache.TryAdd(new CacheKey(as12.Iid, iteration.Iid), new Lazy <Thing>(() => as12)); this.assembler.Cache.TryAdd(new CacheKey(as13.Iid, iteration.Iid), new Lazy <Thing>(() => as13)); this.assembler.Cache.TryAdd(new CacheKey(as14.Iid, iteration.Iid), new Lazy <Thing>(() => as14)); this.assembler.Cache.TryAdd(new CacheKey(as21.Iid, iteration.Iid), new Lazy <Thing>(() => as21)); this.assembler.Cache.TryAdd(new CacheKey(as22.Iid, iteration.Iid), new Lazy <Thing>(() => as22)); this.assembler.Cache.TryAdd(new CacheKey(as23.Iid, iteration.Iid), new Lazy <Thing>(() => as23)); this.assembler.Cache.TryAdd(new CacheKey(as24.Iid, iteration.Iid), new Lazy <Thing>(() => as24)); possibleList1.DefaultState = ps11; as11.Kind = ActualFiniteStateKind.FORBIDDEN; var transactionContext = TransactionContextResolver.ResolveContext(iteration); var context = transactionContext.ContextRoute(); var operationContainer = new OperationContainer(context, model.RevisionNumber); var original = possibleList2.ToDto(); var modify = (CDP4Common.DTO.PossibleFiniteStateList)possibleList2.ToDto(); modify.DefaultState = ps21.Iid; operationContainer.AddOperation(new Operation(original, modify, OperationKind.Update)); Assert.AreEqual(1, operationContainer.Operations.Count()); var modifier = new OperationModifier(this.session.Object); modifier.ModifyOperationContainer(operationContainer); Assert.AreEqual(2, operationContainer.Operations.Count()); var addedOperation = operationContainer.Operations.Last(); var originalActualState = (CDP4Common.DTO.ActualFiniteState)addedOperation.OriginalThing; var modifiedActualState = (CDP4Common.DTO.ActualFiniteState)addedOperation.ModifiedThing; Assert.AreEqual(as11.Iid, originalActualState.Iid); Assert.AreEqual(ActualFiniteStateKind.MANDATORY, modifiedActualState.Kind); Assert.AreEqual(ActualFiniteStateKind.FORBIDDEN, originalActualState.Kind); }