public static PropertyChangedListener ListenForPropertyChanged(this INotifyPropertyChanged target, params string[] properties)
{
var listener = new PropertyChangedListener(properties);
listener.Subscribe(target);
return(listener);
}
protected override void Arrange()
{
base.Arrange();
ApplicationModel = Container.Resolve <ApplicationViewModel>();
ApplicationModelChangedListener = new PropertyChangedListener(ApplicationModel);
}
public void IDataContainer_ShouldRaisePropertyChangedForNestedContainers()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.DataContainer("AA", b => b
.Data("A1", 23)
.Data("A2", 24)
.DataContainer("AAA", b => b
.Data("AA1", 3)))
.Build();
var listener = new PropertyChangedListener(A);
A["A"] = 55;
Assert.Equal("A", listener.LastChangedProperty);
Assert.Single(listener.PropertiesChanged);
IDataContainer AA = (IDataContainer)A["AA"];
AA["A2"] = 42;
Assert.Equal("AA.A2", listener.LastChangedProperty);
Assert.Equal(2, listener.PropertiesChanged.Count);
IDataContainer AAA = (IDataContainer)AA["AAA"];
AAA["AA1"] = 5;
Assert.Equal("AA.AAA.AA1", listener.LastChangedProperty);
Assert.Equal(3, listener.PropertiesChanged.Count);
}
public void IDataContainer_ShouldRaisePropertyChanged()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.Build();
var listener = new PropertyChangedListener(A);
A["A"] = 55;
Assert.Equal("A", listener.LastChangedProperty);
Assert.Single(listener.PropertiesChanged);
A["B"] = 23;
Assert.Equal("B", listener.LastChangedProperty);
Assert.Equal(2, listener.PropertiesChanged.Count);
A["C"] = 29;
Assert.Equal("C", listener.LastChangedProperty);
Assert.Equal(3, listener.PropertiesChanged.Count);
Assert.Contains("A", listener.PropertiesChanged);
Assert.Contains("B", listener.PropertiesChanged);
Assert.Contains("C", listener.PropertiesChanged);
}
protected override void Arrange()
{
base.Arrange();
requiredReferenceingProperty = this.SectionViewModel.Property("RequiredReferenceItem");
requiredReferenceingProperty.Value = "FirstItem";
propertyChangeListener = new PropertyChangedListener(requiredReferenceingProperty);
}
protected override void Arrange()
{
base.Arrange();
step = Container.Resolve <PickExceptionStep>();
propertyChangedListener = new PropertyChangedListener(step);
}
protected override void Act()
{
overridenWrapTypeProperty = base.OverridesProperty.ChildProperties.Where(x => x.PropertyName == "WrapExceptionTypeName").FirstOrDefault();
overridenWrapTypePropertyChangedListener = new PropertyChangedListener(overridenWrapTypeProperty.BindableProperty);
OverridesProperty.Value = OverridesProperty.Converter.ConvertFromString(OverridesProperty, "Override Properties");
}
protected override void Arrange()
{
base.Arrange();
var section = new ElementForValidation();
sectionModel = SectionViewModel.CreateSection(Container, "mock section", section);
validationResult = new ElementValidationResult(sectionModel, "TestMessage", true);
listener = new PropertyChangedListener(validationResult);
}
public void then_overridden_value_changed_if_main_is_changed()
{
using (PropertyChangedListener listener = new PropertyChangedListener(OverriddenExceptionMessage))
{
MainExceptionMessage.Value = "New Value";
Assert.IsTrue(listener.ChangedProperties.Contains("Value"));
Assert.AreEqual("New Value", OverriddenExceptionMessage.Value);
}
}
protected override void Arrange()
{
base.Arrange();
UIServiceMock.Setup(x => x.ShowFileDialog(It.IsAny <FileDialog>())).Returns(new FileDialogResult {
DialogResult = true, FileName = TestConfigurationFilePath
});
UIServiceMock.Setup(x => x.ShowWindow(It.IsAny <WaitDialog>())).Verifiable("Wait dialog not displayed");
shellServiceChangedListener = new PropertyChangedListener(ApplicationModel);
}
public Entity(IntPtr ptr) : base(ptr)
{
Parameters = new Array <Parameter>(Entity_getParameters(NativePtr), p => new Parameter(p));
propertyChangedCallback = Entity_getPropertyChangedListener(NativePtr);
if (propertyChangedCallback == null)
{
propertyChangedCallback = new PropertyChangedListener(() => NotifyPropertyChanged());
Entity_setPropertyChangedListener(NativePtr, propertyChangedCallback);
}
}
protected override void Arrange()
{
base.Arrange();
Steps[0].SetIsValid(true);
changeListener = new PropertyChangedListener(this.Wizard);
commandListener = new CanExecuteChangedListener();
commandListener.Add(this.Wizard.NextCommand);
commandListener.Add(this.Wizard.PreviousCommand);
}
protected override void Arrange()
{
base.Arrange();
defaultCacheManagerProperty = (ElementReferenceProperty)CachingViewModel.Property("DefaultCacheManager");
defaultCacheManagerProperty.Initialize(null);
cacheManager = CachingViewModel.GetDescendentsOfType <CacheManagerData>().First();
defaultCacheManagerPropertyChangedListener = new PropertyChangedListener(defaultCacheManagerProperty);
}
protected override void Arrange()
{
base.Arrange();
var configurationSourceModel = Container.Resolve <ConfigurationSourceModel>();
var viewModel = configurationSourceModel.AddSection(ExceptionHandlingSettings.SectionName, Section);
var loggingModel = configurationSourceModel.AddSection(LoggingSettings.SectionName, LogginSettings);
var logExceptionHandler = viewModel.DescendentElements(x => x.ConfigurationType == typeof(LoggingExceptionHandlerData)).First();
logCategoryProperty = logExceptionHandler.Property("LogCategory");
logCategoryPropertyChangeListener = new PropertyChangedListener(logCategoryProperty);
}
public void when_changing_name_property_on_named_element_name_property_changes()
{
var anyPolicy = viewModel.DescendentElements().Where(x => x.ConfigurationType == typeof(ExceptionPolicyData)).First();
var nameProperty = anyPolicy.Property("Name");
string name = anyPolicy.Name;
using (PropertyChangedListener listener = new PropertyChangedListener(anyPolicy))
{
nameProperty.Value = "new value";
Assert.IsTrue(listener.ChangedProperties.Contains("Name"));
}
}
protected override void Arrange()
{
base.Arrange();
deepestRule = ValidationViewModel.DescendentConfigurationsOfType <AndCompositeValidatorData>()
.Where(x => string.Equals(x.NameProperty.Value, DeepestRuleValidatorName)).First();
walker = new ElementListLayoutWalker(Layout.Contained);
var currentDeepestLayout = walker.LayoutElements().OfType <TwoColumnsLayout>().Where(l => l.Left == deepestRule).First();
var layoutHeader = FindHorizontalList(currentDeepestLayout.ColumnName);
propertyChangedListener = new PropertyChangedListener(layoutHeader);
}
public void when_changing_name_path_changes()
{
var anyPolicy = viewModel.DescendentElements().Where(x => x.ConfigurationType == typeof(ExceptionPolicyData)).First();
string name = anyPolicy.Name;
using (var propListener = new PropertyChangedListener(anyPolicy))
{
anyPolicy.Property("Name").Value = "new name";
Assert.IsTrue(propListener.ChangedProperties.Contains("Path"));
}
}
internal void ListenPropertyChange(BindableProperty bindableProperty, PropertyChangedEventHandler eventHandler)
{
PropertyChangedListener propertyChangedListener;
BindablePropertyChangedEventDict.TryGetValue(bindableProperty.PropertyName, out propertyChangedListener);
if (null == propertyChangedListener)
{
propertyChangedListener = new PropertyChangedListener();
BindablePropertyChangedEventDict.Add(bindableProperty.PropertyName, propertyChangedListener);
}
propertyChangedListener.RegisterListnerHandler(eventHandler);
}
internal static IPropertyChangedListener ListenToChanged(DependencyObject target, DependencyProperty property, Action <object, IDependencyPropertyChangedEventArgs> updateSourceCallback)
{
var storage = GetStorageOrCreateNewIfNotExists(target, property);
List <IPropertyChangedListener> listeners = storage.PropertyListeners;
if (listeners == null)
{
listeners = storage.PropertyListeners = new List <IPropertyChangedListener>();
}
PropertyChangedListener listener = new PropertyChangedListener(storage, updateSourceCallback);
listeners.Add(listener);
return(listener);
}
protected override void Arrange()
{
base.Arrange();
var sourceModel = Container.Resolve <ConfigurationSourceModel>();
LoggingViewModel = sourceModel.AddSection(LoggingSettings.SectionName, LoggingSection);
defaultCategoryProperty = (ElementReferenceProperty)LoggingViewModel.Property("DefaultCategory");
defaultCategoryProperty.Initialize(null);
traceSource = LoggingViewModel.GetDescendentsOfType <TraceSourceData>().First();
defaultCacheManagerPropertyChangedListener = new PropertyChangedListener(defaultCategoryProperty);
}
/// <summary>
/// Initializes a new instance of the <see cref="GroupingCollection"/> class.
/// </summary>
/// <param name="enumerable">The input sequence.</param>
/// <param name="grouping">The underlying grouping.</param>
internal GroupingCollection(IEnumerable <DependencyObject> enumerable, Grouping grouping) : this(new RecomposableCollection <DependencyObject>(grouping.GroupSort(enumerable)))
{
this.grouping = grouping;
propertyListener = new PropertyChangedListener(this);
PropertyChangedEvent.AddListener(grouping, propertyListener);
if (enumerable is INotifyCollectionChanged collection)
{
this.enumerable = enumerable;
collectionListener = new CollectionChangedListener(this);
CollectionChangedEvent.AddListener(collection, collectionListener);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ContainerCollection"/> class.
/// </summary>
/// <param name="items">The input data objects.</param>
/// <param name="converter">The underlying converter.</param>
internal ContainerCollection(IList items, ItemsConverter converter) : this(new ObservableCollection <DependencyObject>(converter.GetContainers(items)))
{
this.converter = converter;
propertyListener = new PropertyChangedListener(this);
PropertyChangedEvent.AddListener(converter, propertyListener);
if (items is INotifyCollectionChanged collection)
{
this.items = items;
collectionListener = new CollectionChangedListener(this);
CollectionChangedEvent.AddListener(collection, collectionListener);
}
}
internal static IPropertyChangedListener ListenToChanged(DependencyObject target, DependencyProperty property, Action <object, IDependencyPropertyChangedEventArgs> updateSourceCallback)
{
INTERNAL_PropertyStorage storage;
TryGetStorage(target, property, true /*create*/, out storage);
List <IPropertyChangedListener> listeners = storage.PropertyListeners;
if (listeners == null)
{
listeners = storage.PropertyListeners = new List <IPropertyChangedListener>();
}
PropertyChangedListener listener = new PropertyChangedListener(storage, updateSourceCallback);
listeners.Add(listener);
return(listener);
}
protected override void Act()
{
firstHandler =
ViewModel.DescendentElements(x => x.ConfigurationType == typeof(TestHandlerData)).OfType
<CollectionElementViewModel>()
.Where(x => x.Name == "One").Single();
firstHandler.Select();
firstElementChangeListener = new PropertyChangedListener(firstHandler);
secondHandler =
ViewModel.DescendentElements(x => x.ConfigurationType == typeof(TestHandlerData)).OfType
<CollectionElementViewModel>()
.Where(x => x.Name == "Two").Single();
secondHandler.MoveUp.Execute(null);
}
public void IDataContainer_ShouldNotRaisePropertyChangedIfValueSame()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.Build();
var listener = new PropertyChangedListener(A);
A["A"] = 1;
Assert.True(string.IsNullOrEmpty(listener.LastChangedProperty));
Assert.Empty(listener.PropertiesChanged);
A["A"] = 2;
Assert.Equal("A", listener.LastChangedProperty);
Assert.NotEmpty(listener.PropertiesChanged);
}
public void IDataContainer_ObjectDataObjectRaisesPropertyChangedWhenCLRObjectChanges()
{
BindingTestObject obj = new BindingTestObject();
IDataContainer A = DataContainerBuilder.Create("A")
.Data("Obj1", obj, SerializationFormat.Container)
.Data("Obj2", obj, SerializationFormat.Xml)
.Data("Obj3", obj, SerializationFormat.Json)
.Build();
var listener = new PropertyChangedListener(A);
obj.IntProperty = 44;
Assert.Contains("Obj1", listener.PropertiesChanged);
Assert.Contains("Obj2", listener.PropertiesChanged);
Assert.Contains("Obj3", listener.PropertiesChanged);
Assert.Equal("Obj3", listener.LastChangedProperty);
}
public void IDataContainer_EnableChangeNotificationWorks()
{
IDataContainer A = DataContainerBuilder.Create("A")
.Data("A", 1)
.Data("B", 2)
.Data("C", 3)
.Build();
A.EnableChangeNotification = false;
var listener = new PropertyChangedListener(A);
A["A"] = 55;
Assert.Null(listener.LastChangedProperty);
Assert.Empty(listener.PropertiesChanged);
A.EnableChangeNotification = true;
A["B"] = 23;
Assert.Equal("B", listener.LastChangedProperty);
Assert.Single(listener.PropertiesChanged);
}
public void IDataContainer_RefreshUpdatesChangedValue()
{
IDataContainer A = DataContainerBuilder.Create()
.Data("A", 2)
.Data("B", 3)
.Data("C", 4)
.Build();
IDataContainer A2 = DataContainerBuilder.Create()
.Data("A", 2)
.Data("B", 3)
.Data("C", 5)
.Build();
var listener = new PropertyChangedListener(A);
Assert.NotEqual(A["C"], A2["C"]);
A.Refresh(A2);
Assert.Equal(A["C"], A2["C"]);
Assert.Equal("C", listener.LastChangedProperty);
Assert.Single(listener.PropertiesChanged);
}
protected override void Arrange()
{
base.Arrange();
applicationModelChangedListener = new PropertyChangedListener(base.ApplicationModel);
}
protected override void Arrange()
{
base.Arrange();
propertyPropertyChangedListener = new PropertyChangedListener(base.property.BindableProperty);
}
