Пример #1
0
        public void DisagreeingValues()
        {
            const string name = "name";
            var          info = new Mock <IEventInfo> ();

            info.SetupGet(i => i.Name).Returns(name);

            var editor = new MockObjectEditor {
                Events = new[] { info.Object }
            };
            const string handler = "handler";

            editor.AttachHandlerAsync(info.Object, handler);

            var editor2 = new MockObjectEditor {
                Events = new[] { info.Object }
            };

            editor.AttachHandlerAsync(info.Object, "handler2");

            var ev = new EventViewModel(MockEditorProvider.MockPlatform, info.Object, new[] { editor, editor2 });

            Assert.That(ev.MethodName, Is.Null);
            Assert.That(ev.MultipleValues, Is.True);
        }
Пример #2
0
        public void FilterGroupableWhenNotGrouped()
        {
            var stringProvider = new StringViewModelTests();

            var stringProperty1 = stringProvider.GetPropertyMock("string1");
            var stringProperty2 = stringProvider.GetPropertyMock("string2");

            var editor = new MockObjectEditor(stringProperty1.Object, stringProperty2.Object);

            var provider = new Mock <IEditorProvider> ();

            provider.Setup(p => p.GetObjectEditorAsync(editor.Target)).ReturnsAsync(editor);

            var platform = new TargetPlatform(provider.Object)
            {
                GroupedTypes = new Dictionary <Type, string> {
                    { typeof(string), "B" }
                }
            };

            var vm = new PanelViewModel(platform);

            Assume.That(vm.ArrangeMode, Is.EqualTo(PropertyArrangeMode.Name));
            vm.SelectedObjects.Add(editor.Target);
            Assume.That(vm.ArrangedEditors[0].Editors.Count, Is.EqualTo(2));

            vm.FilterText = "A";
            Assert.That(vm.ArrangedEditors.Count, Is.EqualTo(0));
        }
        public void HasChildElementsUpdates()
        {
            var property = new Mock <IPropertyInfo> ();

            property.Setup(p => p.Name).Returns("Name");
            property.Setup(p => p.Category).Returns("Category");
            property.Setup(p => p.Type).Returns(typeof(string));
            property.Setup(p => p.IsUncommon).Returns(false);

            var editor     = new MockObjectEditor(property.Object);
            var propertyVm = new StringPropertyViewModel(MockEditorProvider.MockPlatform, property.Object, new[] { editor });
            var group      = new PanelGroupViewModel(MockEditorProvider.MockPlatform, "Category", new[] { propertyVm });

            Assert.That(group.HasChildElements, Is.True);

            bool changed = false;

            group.PropertyChanged += (sender, args) => {
                if (args.PropertyName == nameof(PanelGroupViewModel.HasChildElements))
                {
                    changed = true;
                }
            };

            group.Remove(propertyVm);
            Assert.That(group.HasChildElements, Is.False);
            Assert.That(changed, Is.True, "INPC did not fire for HasChildElements during remove");
            changed = false;

            group.Add(propertyVm);
            Assert.That(group.HasChildElements, Is.True);
            Assert.That(changed, Is.True, "INPC did not fire for HasChildElements during add");
        }
        public void ResourcesChangedUpdatesResources()
        {
            var mockProperty = new Mock <IPropertyInfo> ();

            mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonBrush));
            var mockEditor = new MockObjectEditor(mockProperty.Object);

            var resource1 = new Resource("first");
            var resources = new List <Resource> {
                resource1
            };

            var provider = new Mock <IResourceProvider>();

            provider.Setup(p => p.GetResourceSourcesAsync(It.IsAny <object> ())).ReturnsAsync(new[] { MockResourceProvider.SystemResourcesSource });
            provider.Setup(p => p.GetResourcesAsync(It.IsAny <object> (), mockProperty.Object, CancellationToken.None)).ReturnsAsync(resources);

            var vm = new BrushPropertyViewModel(new TargetPlatform(new MockEditorProvider(), provider.Object), mockProperty.Object, new [] { mockEditor });

            Assume.That(vm.ResourceSelector.Resources, Contains.Item(resource1));

            var resource2 = new Resource("second");

            resources.Add(resource2);

            provider.Raise(rp => rp.ResourcesChanged += null, new ResourcesChangedEventArgs());
            Assert.That(vm.ResourceSelector.Resources, Contains.Item(resource1));
            Assert.That(vm.ResourceSelector.Resources, Contains.Item(resource2));
        }
Пример #5
0
        public void GroupedPropertiesArrange()
        {
            var intProvider    = new IntegerPropertyViewModelTests();
            var stringProvider = new StringViewModelTests();
            var brushProvider  = new SolidBrushPropertyViewModelTests();

            var intProperty     = intProvider.GetPropertyMock("int", "A");
            var stringProperty1 = stringProvider.GetPropertyMock("string1");
            var stringProperty2 = stringProvider.GetPropertyMock("string2");
            var brushProperty   = brushProvider.GetPropertyMock("brush", "C");

            var editor = new MockObjectEditor(intProperty.Object, stringProperty1.Object, stringProperty2.Object, brushProperty.Object);

            var provider = new Mock <IEditorProvider> ();

            provider.Setup(p => p.GetObjectEditorAsync(editor.Target)).ReturnsAsync(editor);

            var platform = new TargetPlatform(provider.Object)
            {
                GroupedTypes = new Dictionary <Type, string> {
                    { typeof(string), "B" }
                }
            };

            var vm = new PanelViewModel(platform);

            Assume.That(vm.ArrangeMode, Is.EqualTo(PropertyArrangeMode.Name));

            vm.ArrangeMode = PropertyArrangeMode.Category;
            vm.SelectedObjects.Add(editor.Target);
            Assert.That(vm.ArrangedEditors[0].Category, Is.EqualTo("A"));
            Assert.That(vm.ArrangedEditors[1].Category, Is.EqualTo("B"));
            Assert.That(vm.ArrangedEditors[2].Category, Is.EqualTo("C"));
        }
        public void ChangingEditorsUpdatesResources()
        {
            var mockProperty = new Mock <IPropertyInfo> ();

            mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonBrush));
            var mockEditor = new MockObjectEditor(mockProperty.Object);

            var vm = new BrushPropertyViewModel(new TargetPlatform(new MockEditorProvider(), new MockResourceProvider()), mockProperty.Object, new [] { mockEditor });

            var changed = false;

            vm.PropertyChanged += (s, e) => {
                if (e.PropertyName == nameof(BrushPropertyViewModel.ResourceSelector))
                {
                    changed = true;
                }
            };
            var rs1 = vm.ResourceSelector;

            vm.Editors.Add(new MockObjectEditor());
            var rs2 = vm.ResourceSelector;

            Assert.IsTrue(changed);
            Assert.AreNotEqual(rs1, rs2);
        }
Пример #7
0
        public void UnavailablePropertyNotInList()
        {
            IObjectEditor editor;

            var constraint = new Mock <IAvailabilityConstraint>();
            var prop       = new Mock <IPropertyInfo> ();

            prop.SetupGet(p => p.Type).Returns(typeof(int));
            prop.SetupGet(p => p.AvailabilityConstraints).Returns(new[] { constraint.Object });

            var constraint2 = new Mock <IAvailabilityConstraint> ();
            var prop2       = new Mock <IPropertyInfo> ();

            prop2.SetupGet(p => p.Type).Returns(typeof(int));
            prop2.SetupGet(p => p.AvailabilityConstraints).Returns(new[] { constraint2.Object });

            editor = new MockObjectEditor(prop.Object, prop2.Object);
            constraint.Setup(c => c.GetIsAvailableAsync(editor)).ReturnsAsync(true);
            constraint2.Setup(c => c.GetIsAvailableAsync(editor)).ReturnsAsync(false);

            var pvm  = new PropertyViewModel <int> (TargetPlatform.Default, prop.Object, new[] { editor });
            var pvm2 = new PropertyViewModel <int> (TargetPlatform.Default, prop2.Object, new[] { editor });

            var vm = new PropertyGroupViewModel(TargetPlatform.Default, "category", new[] { pvm, pvm2 }, new [] { editor });

            Assert.That(vm.Properties, Contains.Item(pvm));
            Assert.That(vm.Properties, Does.Not.Contain(pvm2));
        }
Пример #8
0
        public async Task ResourceBrushMatchesMaterialStaysResource()
        {
            var platform = new TargetPlatform(new MockEditorProvider())
            {
                SupportsMaterialDesign = true
            };
            var mockProperty = new Mock <IPropertyInfo> ();

            mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonSolidBrush));

            var mockEditor = new MockObjectEditor(mockProperty.Object);

            var provider  = new MockResourceProvider();
            var resources = await provider.GetResourcesAsync(mockEditor.Target, mockProperty.Object, CancellationToken.None);

            var resource = resources.OfType <Resource <CommonSolidBrush> > ().First(r => r.Value == new CommonSolidBrush(0, 0, 0));

            await mockEditor.SetValueAsync(mockProperty.Object, new ValueInfo <CommonSolidBrush> {
                Source           = ValueSource.Resource,
                Value            = resource.Value,
                SourceDescriptor = resource
            });

            var vm = new BrushPropertyViewModel(platform, mockProperty.Object, new[] { mockEditor });

            Assume.That(vm.ValueSource, Is.EqualTo(ValueSource.Resource));
            Assert.That(vm.SelectedBrushType, Is.EqualTo(CommonBrushType.Resource));
        }
        public void TypeRequestedWhenMultipleAssignableTypes()
        {
            object value = new object();

            var p = CreatePropertyMock("prop");

            var childsubInfo = GetTypeInfo(typeof(SubChildClass));
            var editor       = new MockObjectEditor(new[] { p.Object }, new Dictionary <IPropertyInfo, IReadOnlyList <ITypeInfo> > {
                {
                    p.Object,
                    new[] {
                        GetTypeInfo(typeof(ChildClass)),
                        childsubInfo
                    }
                }
            });

            var providerMock = CreateProviderMock(value, new MockObjectEditor {
                Target = value
            });

            var vm = new ObjectPropertyViewModel(providerMock.Object, TargetPlatform.Default, p.Object, new[] { editor });

            bool requested = false;

            vm.TypeRequested += (sender, args) => {
                requested = true;
            };

            Assume.That(vm.CreateInstanceCommand.CanExecute(childsubInfo), Is.True);
            vm.CreateInstanceCommand.Execute(childsubInfo);
            Assert.That(requested, Is.True, "TypeRequested was not raised");
        }
        public async Task MultiValueSourcesUnknown()
        {
            object value = new object();

            var p = CreatePropertyMock("prop");

            var childsubInfo = GetTypeInfo(typeof(SubChildClass));
            var editor       = new MockObjectEditor(new[] { p.Object }, new Dictionary <IPropertyInfo, IReadOnlyList <ITypeInfo> > {
                { p.Object, new[] { childsubInfo } }
            });
            await editor.SetValueAsync(p.Object, new ValueInfo <object> {
                Value           = value,
                Source          = ValueSource.Local,
                ValueDescriptor = childsubInfo
            });

            var editor2 = new MockObjectEditor(new[] { p.Object }, new Dictionary <IPropertyInfo, IReadOnlyList <ITypeInfo> > {
                { p.Object, new[] { childsubInfo } }
            });
            await editor2.SetValueAsync(p.Object, new ValueInfo <object> {
                Value           = value,
                Source          = ValueSource.Default,
                ValueDescriptor = childsubInfo
            });

            var providerMock = CreateProviderMock(value, new MockObjectEditor {
                Target = value
            });

            var vm = new ObjectPropertyViewModel(providerMock.Object, TargetPlatform.Default, p.Object, new[] { editor, editor2 });

            Assert.That(vm.ValueSource, Is.EqualTo(ValueSource.Unknown));
        }
        private static BrushPropertyViewModel PrepareMockViewModel()
        {
            var mockProperty = new Mock <IPropertyInfo> ();

            mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonSolidBrush));
            mockProperty.As <IColorSpaced> ().SetupGet(pi => pi.ColorSpaces).Returns(SampleColorSpaces);
            var mockEditor = new MockObjectEditor(mockProperty.Object);

            return(new BrushPropertyViewModel(MockEditorProvider.MockPlatform, mockProperty.Object, new[] { mockEditor }));
        }
Пример #12
0
        public void AvailabilityUpdates()
        {
            IObjectEditor editor = null;

            var constraint = new Mock <IAvailabilityConstraint>();
            var prop       = new Mock <IPropertyInfo> ();

            prop.SetupGet(p => p.Type).Returns(typeof(int));
            prop.SetupGet(p => p.AvailabilityConstraints).Returns(new[] { constraint.Object });

            bool isAvailable = false;

            var constraint2 = new Mock <IAvailabilityConstraint> ();

            constraint2.SetupGet(a => a.ConstrainingProperties).Returns(new[] { prop.Object });
            var prop2 = new Mock <IPropertyInfo> ();

            prop2.SetupGet(p => p.Type).Returns(typeof(int));
            prop2.SetupGet(p => p.AvailabilityConstraints).Returns(new[] { constraint2.Object });

            editor = new MockObjectEditor(prop.Object, prop2.Object);
            constraint.Setup(c => c.GetIsAvailableAsync(editor)).ReturnsAsync(true);
            constraint2.Setup(c => c.GetIsAvailableAsync(editor)).ReturnsAsync(() => isAvailable);

            var pvm  = new PropertyViewModel <int> (TargetPlatform.Default, prop.Object, new[] { editor });
            var pvm2 = new PropertyViewModel <int> (TargetPlatform.Default, prop2.Object, new[] { editor });

            var vm = new PropertyGroupViewModel(TargetPlatform.Default, "category", new[] { pvm, pvm2 }, new [] { editor });

            Assume.That(vm.Properties, Contains.Item(pvm));
            Assume.That(vm.Properties, Does.Not.Contain(pvm2));

            INotifyCollectionChanged notify = vm.Properties as INotifyCollectionChanged;

            Assume.That(notify, Is.Not.Null);

            bool changed = false;

            notify.CollectionChanged += (sender, args) => {
                if (args.Action == NotifyCollectionChangedAction.Add && args.NewItems[0] == pvm2)
                {
                    changed = true;
                }
            };

            isAvailable = true;

            // Bit of integration here, constrainting property changes will trigger availability requery
            pvm.Value = 5;

            Assert.That(changed, Is.True);
            Assert.That(vm.Properties, Contains.Item(pvm));
            Assert.That(vm.Properties, Contains.Item(pvm2));
        }
        private static BrushPropertyViewModel PrepareMockViewModel()
        {
            var platform = new TargetPlatform {
                SupportsMaterialDesign = true
            };
            var mockProperty = new Mock <IPropertyInfo> ();

            mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonSolidBrush));
            var mockEditor = new MockObjectEditor(mockProperty.Object);

            return(new BrushPropertyViewModel(platform, mockProperty.Object, new[] { mockEditor }));
        }
        public async Task ValidatorMultiSelect()
        {
            var p         = GetPropertyMock();
            var validator = p.As <IValidator <IReadOnlyList <int> > > ();

            validator.Setup(l => l.IsValid(It.IsAny <IReadOnlyList <int> > ())).Returns <IReadOnlyList <int> > (l => !(l == null || l.Count == 0));

            var editor = new MockObjectEditor(p.Object);
            await editor.SetValueAsync(p.Object, new ValueInfo <int> {
                Value  = (int)FlagsTestEnum.Flag1,
                Source = ValueSource.Local
            });

            var editor2 = new MockObjectEditor(p.Object);
            await editor2.SetValueAsync(p.Object, new ValueInfo <int> {
                Value  = (int)FlagsTestEnum.Flag2,
                Source = ValueSource.Local
            });

            var vm = GetViewModel(p.Object, new [] { editor, editor2 });

            Assume.That(vm.Choices.Count, Is.EqualTo(7));

            var flag1choice = vm.Choices.Single(c => c.Value == (int)FlagsTestEnum.Flag1);

            Assume.That(flag1choice.IsFlagged, Is.Null);
            var flag2choice = vm.Choices.Single(c => c.Value == (int)FlagsTestEnum.Flag2);

            Assume.That(flag1choice.IsFlagged, Is.Null);
            var flag3choice = vm.Choices.Single(c => c.Value == (int)FlagsTestEnum.Flag3);

            Assume.That(flag3choice.IsFlagged, Is.False);

            // initial state has o1: flag1, o2: flag2.
            // unflagging flag1 results in invalid o1 property state
            // impl swaps flag1 back on, now o1 is flag1; o2 is flag1|flag2

            flag1choice.IsFlagged = false;

            var setValue = await editor.GetValueAsync <IReadOnlyList <int> > (p.Object);

            var setValue2 = await editor2.GetValueAsync <IReadOnlyList <int> > (p.Object);

            CollectionAssert.AreEquivalent(new[] { (int)FlagsTestEnum.Flag1 }, setValue.Value);
            CollectionAssert.AreEquivalent(new[] { (int)FlagsTestEnum.Flag1, (int)FlagsTestEnum.Flag2 }, setValue2.Value);

            Assert.That(flag1choice.IsFlagged, Is.True);
            Assert.That(flag2choice.IsFlagged, Is.Null);
        }
Пример #15
0
        public async Task CanDelve()
        {
            object value = new object();

            var p = CreatePropertyMock("prop");

            var childsubInfo = GetTypeInfo(typeof(SubChildClass));
            var editor       = new MockObjectEditor(new[] { p.Object }, new Dictionary <IPropertyInfo, IReadOnlyList <ITypeInfo> > {
                { p.Object, new[] { childsubInfo } }
            });
            await editor.SetValueAsync(p.Object, new ValueInfo <object> {
                Value = value, Source = ValueSource.Local
            });

            var providerMock = CreateProviderMock(value, new MockObjectEditor {
                Target = value
            });

            var vm = new ObjectPropertyViewModel(new TargetPlatform(providerMock.Object), p.Object, new IObjectEditor[0]);

            Assert.That(vm.CanDelve, Is.False);

            bool changed = false;

            vm.PropertyChanged += (sender, args) => {
                if (args.PropertyName == nameof(ObjectPropertyViewModel.CanDelve))
                {
                    changed = true;
                }
            };

            vm.Editors.Add(editor);

            Assert.That(vm.CanDelve, Is.True);
            Assert.That(changed, Is.True, "PropertyChanged for CanDelve didn't fire adding");

            changed = false;
            vm.Editors.Clear();

            Assert.That(vm.CanDelve, Is.False);
            Assert.That(changed, Is.True, "PropertyChanged for CanDelve didn't fire clearing");

            changed = false;
            vm.Editors.Add(null);

            Assert.That(vm.CanDelve, Is.False);
            Assert.That(changed, Is.False, "PropertyChanged for CanDelve when hasn't changed");
        }
Пример #16
0
        public void FilteredOutOfChildren()
        {
            IObjectEditor editor = null;

            var prop = new Mock <IPropertyInfo> ();

            prop.SetupGet(p => p.Type).Returns(typeof(int));
            prop.SetupGet(p => p.Name).Returns("one");

            var prop2 = new Mock <IPropertyInfo> ();

            prop2.SetupGet(p => p.Type).Returns(typeof(int));
            prop2.SetupGet(p => p.Name).Returns("two");

            editor = new MockObjectEditor(prop.Object, prop2.Object);
            var pvm  = new PropertyViewModel <int> (TargetPlatform.Default, prop.Object, new[] { editor });
            var pvm2 = new PropertyViewModel <int> (TargetPlatform.Default, prop2.Object, new[] { editor });

            var vm = new PropertyGroupViewModel(TargetPlatform.Default, "category", new[] { pvm, pvm2 }, new [] { editor });

            Assume.That(vm.Properties, Contains.Item(pvm));
            Assume.That(vm.Properties, Contains.Item(pvm2));

            bool changed = false;

            vm.PropertyChanged += (sender, args) => {
                if (args.PropertyName == nameof(PropertyGroupViewModel.HasChildElements))
                {
                    changed = true;
                }
            };

            vm.FilterText = "1";

            Assert.That(changed, Is.True, "HasChildElements didn't change");
            Assert.That(vm.HasChildElements, Is.False);
            Assert.That(vm.Properties, Does.Not.Contain(pvm2));
            Assert.That(vm.Properties, Does.Not.Contain(pvm));

            changed       = false;
            vm.FilterText = null;

            Assert.That(changed, Is.True, "HasChildElements didn't change");
            Assert.That(vm.HasChildElements, Is.True);
            Assert.That(vm.Properties, Contains.Item(pvm2));
            Assert.That(vm.Properties, Contains.Item(pvm));
        }
Пример #17
0
        public void MethodName()
        {
            const string name = "name";
            var          info = new Mock <IEventInfo> ();

            info.SetupGet(i => i.Name).Returns(name);

            var editor = new MockObjectEditor {
                Events = new[] { info.Object }
            };
            const string handler = "handler";

            editor.AttachHandlerAsync(info.Object, handler);

            var ev = new EventViewModel(MockEditorProvider.MockPlatform, info.Object, new[] { editor });

            Assert.That(ev.MethodName, Is.EqualTo(handler));
        }
Пример #18
0
        public void Filtered()
        {
            IObjectEditor editor = null;

            var prop = new Mock <IPropertyInfo> ();

            prop.SetupGet(p => p.Type).Returns(typeof(int));
            prop.SetupGet(p => p.Name).Returns("one");

            var prop2 = new Mock <IPropertyInfo> ();

            prop2.SetupGet(p => p.Type).Returns(typeof(int));
            prop2.SetupGet(p => p.Name).Returns("two");

            editor = new MockObjectEditor(prop.Object, prop2.Object);
            var pvm  = new PropertyViewModel <int> (TargetPlatform.Default, prop.Object, new[] { editor });
            var pvm2 = new PropertyViewModel <int> (TargetPlatform.Default, prop2.Object, new[] { editor });

            var vm = new PropertyGroupViewModel(TargetPlatform.Default, "category", new[] { pvm, pvm2 }, new [] { editor });

            Assume.That(vm.Properties, Contains.Item(pvm));
            Assume.That(vm.Properties, Contains.Item(pvm2));

            INotifyCollectionChanged notify = vm.Properties as INotifyCollectionChanged;

            Assume.That(notify, Is.Not.Null);

            bool changed = false;

            notify.CollectionChanged += (sender, args) => {
                if (args.Action == NotifyCollectionChangedAction.Remove && args.OldItems[0] == pvm)
                {
                    changed = true;
                }
            };

            vm.FilterText = "t";

            Assert.That(changed, Is.True, "Collection changed event didn't trigger correctly");
            Assert.That(vm.Properties, Contains.Item(pvm2));
            Assert.That(vm.Properties, Does.Not.Contain(pvm));
            Assert.That(vm.HasChildElements, Is.True);
        }
        public void SettingValueTriggersOpacityChange()
        {
            var mockProperty = new Mock <IPropertyInfo> ();

            mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonBrush));
            var mockEditor = new MockObjectEditor(mockProperty.Object);

            var vm      = new BrushPropertyViewModel(MockEditorProvider.MockPlatform, mockProperty.Object, new[] { mockEditor });
            var changed = false;

            vm.PropertyChanged += (s, e) => {
                if (e.PropertyName == nameof(BrushPropertyViewModel.Opacity))
                {
                    changed = true;
                }
            };
            vm.Value = GetRandomTestValue();
            Assert.IsTrue(changed);
        }
Пример #20
0
        public void NoValueToMaterialSets()
        {
            var platform = new TargetPlatform(new MockEditorProvider())
            {
                SupportsMaterialDesign = true
            };
            var mockProperty = new Mock <IPropertyInfo> ();

            mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonSolidBrush));
            var mockEditor = new MockObjectEditor(mockProperty.Object);

            var vm = new BrushPropertyViewModel(platform, mockProperty.Object, new[] { mockEditor });

            Assume.That(vm.MaterialDesign.Color, Is.EqualTo(new CommonColor(0, 0, 0)));
            Assume.That(vm.ValueSource, Is.EqualTo(ValueSource.Default).Or.EqualTo(ValueSource.Unset));
            Assume.That(vm.SelectedBrushType, Is.EqualTo(CommonBrushType.NoBrush));

            vm.SelectedBrushType = CommonBrushType.MaterialDesign;
            Assert.That(vm.ValueSource, Is.EqualTo(ValueSource.Local));
        }
Пример #21
0
        public async Task PropertyRootChildren()
        {
            var target = new object();

            var property = new Mock <IPropertyInfo> ();

            property.SetupGet(p => p.ValueSources).Returns(ValueSources.Local | ValueSources.Binding);
            property.SetupGet(p => p.Type).Returns(typeof(object));
            property.SetupGet(p => p.Name).Returns("name");
            property.SetupGet(p => p.RealType).Returns(typeof(object).ToTypeInfo());
            property.SetupGet(p => p.CanWrite).Returns(true);

            var editor = GetBasicEditor(target, property.Object);

            var controlTarget = new MockWpfControl();
            var controlEditor = new MockObjectEditor(controlTarget);
            var provider      = new MockEditorProvider(controlEditor);

            var source = new BindingSource("Control", BindingSourceType.Object);
            var bpmock = new Mock <IBindingProvider> ();

            bpmock.Setup(bp => bp.GetBindingSourcesAsync(target, property.Object)).ReturnsAsync(new[] { source });
            bpmock.Setup(bp => bp.GetRootElementsAsync(source, target)).ReturnsAsync(new[] { controlTarget });
            bpmock.Setup(bp => bp.GetValueConverterResourcesAsync(It.IsAny <object> ())).ReturnsAsync(new Resource[0]);

            var vm = new CreateBindingViewModel(new TargetPlatform(provider, bpmock.Object), editor.Object, property.Object);

            Assume.That(vm.SelectedBindingSource, Is.EqualTo(source));
            Assume.That(vm.PropertyRoot, Is.Not.Null);
            await vm.PropertyRoot.Task;

            var childrenProperty = controlEditor.Properties.First(p => p.Type == typeof(CommonThickness));
            var element          = vm.PropertyRoot.Value.Children.First(p => Equals(p.Property, childrenProperty));

            Assert.That(element.Children, Is.Not.Null);

            await element.Children.Task;
            var expected = await provider.GetPropertiesForTypeAsync(typeof(CommonThickness).ToTypeInfo());

            CollectionAssert.AreEqual(expected, element.Children.Value.Select(te => te.Property));
        }
Пример #22
0
        public void PropertyGroup()
        {
            IObjectEditor editor = null;

            var prop = new Mock <IPropertyInfo> ();

            prop.SetupGet(p => p.Type).Returns(typeof(int));

            var prop2 = new Mock <IPropertyInfo> ();

            prop2.SetupGet(p => p.Type).Returns(typeof(int));

            editor = new MockObjectEditor(prop.Object, prop2.Object);
            var pvm  = new PropertyViewModel <int> (TargetPlatform.Default, prop.Object, new[] { editor });
            var pvm2 = new PropertyViewModel <int> (TargetPlatform.Default, prop2.Object, new[] { editor });

            var vm = new PropertyGroupViewModel(TargetPlatform.Default, "category", new[] { pvm, pvm2 }, new [] { editor });

            Assert.That(vm.Properties, Contains.Item(pvm));
            Assert.That(vm.Properties, Contains.Item(pvm2));
        }
Пример #23
0
        public async Task MultiValueTypesNull()
        {
            object value = new object(), value2 = new object();

            var p = CreatePropertyMock("prop");

            var childsubInfo = GetTypeInfo(typeof(SubChildClass));
            var childInfo    = GetTypeInfo(typeof(ChildClass));
            var editor       = new MockObjectEditor(new[] { p.Object }, new Dictionary <IPropertyInfo, IReadOnlyList <ITypeInfo> > {
                { p.Object, new[] { childInfo, childsubInfo } }
            });
            await editor.SetValueAsync(p.Object, new ValueInfo <object> {
                Value           = value,
                Source          = ValueSource.Local,
                ValueDescriptor = childInfo
            });

            var editor2 = new MockObjectEditor(new[] { p.Object }, new Dictionary <IPropertyInfo, IReadOnlyList <ITypeInfo> > {
                { p.Object, new[] { childInfo, childsubInfo } }
            });
            await editor2.SetValueAsync(p.Object, new ValueInfo <object> {
                Value           = value2,
                Source          = ValueSource.Local,
                ValueDescriptor = childsubInfo
            });

            var providerMock = CreateProviderMock(value, new MockObjectEditor {
                Target = value
            });

            providerMock.Setup(a => a.GetObjectEditorAsync(value2)).ReturnsAsync(new MockObjectEditor {
                Target = value2
            });

            var vm = new ObjectPropertyViewModel(new TargetPlatform(providerMock.Object), p.Object, new[] { editor, editor2 });

            Assume.That(vm.ValueSource, Is.EqualTo(ValueSource.Local));
            Assert.That(vm.ValueType, Is.Null);
        }
        public async Task ClearedValueSourcesDefault()
        {
            object value = new object();

            var p = CreatePropertyMock("prop");

            var childsubInfo = GetTypeInfo(typeof(SubChildClass));
            var editor       = new MockObjectEditor(new[] { p.Object }, new Dictionary <IPropertyInfo, IReadOnlyList <ITypeInfo> > {
                { p.Object, new[] { childsubInfo } }
            });
            await editor.SetValueAsync(p.Object, new ValueInfo <object> {
                Value           = value,
                Source          = ValueSource.Local,
                ValueDescriptor = childsubInfo
            });

            var providerMock = CreateProviderMock(value, new MockObjectEditor {
                Target = value
            });

            var vm = new ObjectPropertyViewModel(providerMock.Object, TargetPlatform.Default, p.Object, new[] { editor });

            Assume.That(vm.ValueSource, Is.EqualTo(ValueSource.Local));

            bool changed = false;

            vm.PropertyChanged += (sender, args) => {
                if (args.PropertyName == nameof(ObjectPropertyViewModel.ValueSource))
                {
                    changed = true;
                }
            };

            vm.Editors.Clear();
            Assert.That(vm.ValueSource, Is.EqualTo(ValueSource.Default));
            Assert.That(changed, Is.True, "PropertyChanged did not fire for ValueSource");
        }
Пример #25
0
        public void ReturnedNullTypeCancels()
        {
            object value        = new object();
            var    p            = CreatePropertyMock("prop");
            var    childsubInfo = GetTypeInfo(typeof(SubChildClass));
            var    editor       = new MockObjectEditor(new[] { p.Object }, new Dictionary <IPropertyInfo, IReadOnlyList <ITypeInfo> > {
                {
                    p.Object,
                    new[] {
                        GetTypeInfo(typeof(ChildClass)),
                        childsubInfo
                    }
                }
            });

            var providerMock = CreateProviderMock(value, new MockObjectEditor {
                Target = value
            });
            var vm = new ObjectPropertyViewModel(new TargetPlatform(providerMock.Object), p.Object, new[] { editor });

            var  tcs       = new TaskCompletionSource <ITypeInfo> ();
            bool requested = false;

            vm.TypeRequested += (sender, args) => {
                requested         = true;
                args.SelectedType = tcs.Task;
            };

            Assume.That(vm.CreateInstanceCommand.CanExecute(childsubInfo), Is.True);
            vm.CreateInstanceCommand.Execute(null);
            Assume.That(requested, Is.True);

            tcs.SetResult(null);

            providerMock.Verify(ep => ep.CreateObjectAsync(null), Times.Never);
        }
        public async Task SetFlagsMultipleValues()
        {
            FlagsTestEnum value  = FlagsTestEnum.Flag2 | FlagsTestEnum.Flag3;
            FlagsTestEnum value2 = FlagsTestEnum.Flag2 | FlagsTestEnum.Flag4;

            var p = GetPropertyMock();

            var editor = new MockObjectEditor(p.Object);
            await editor.SetValueAsync(p.Object, new ValueInfo <int> {
                Value  = (int)value,
                Source = ValueSource.Local
            });

            var editor2 = new MockObjectEditor(p.Object);
            await editor2.SetValueAsync(p.Object, new ValueInfo <int> {
                Value  = (int)value2,
                Source = ValueSource.Local
            });

            var vm = GetViewModel(p.Object, new [] { editor, editor2 });

            Assume.That(vm.Choices.Count, Is.EqualTo(7));
            Assume.That(vm.Value, Is.EqualTo(default(int)));

            var flag1Choice = vm.Choices.Single(v => v.Name == nameof(FlagsTestEnum.Flag1));

            Assume.That(flag1Choice.Value, Is.EqualTo((int)FlagsTestEnum.Flag1));
            Assume.That(flag1Choice.IsFlagged.HasValue && !flag1Choice.IsFlagged.Value);
            var flag2Choice = vm.Choices.Single(v => v.Name == nameof(FlagsTestEnum.Flag2));

            Assume.That(flag2Choice.Value, Is.EqualTo((int)FlagsTestEnum.Flag2));
            Assume.That(flag2Choice.IsFlagged.HasValue && flag2Choice.IsFlagged.Value, Is.True);
            var flag3Choice = vm.Choices.Single(v => v.Name == nameof(FlagsTestEnum.Flag3));

            Assume.That(flag3Choice.Value, Is.EqualTo((int)FlagsTestEnum.Flag3));
            Assume.That(flag3Choice.IsFlagged.HasValue, Is.False);
            var flag4Choice = vm.Choices.Single(v => v.Name == nameof(FlagsTestEnum.Flag4));

            Assume.That(flag4Choice.Value, Is.EqualTo((int)FlagsTestEnum.Flag4));
            Assume.That(flag4Choice.IsFlagged.HasValue, Is.False);
            var flag5Choice = vm.Choices.Single(v => v.Name == nameof(FlagsTestEnum.Flag5));

            Assume.That(flag5Choice.Value, Is.EqualTo((int)FlagsTestEnum.Flag5));
            Assume.That(flag5Choice.IsFlagged.HasValue, Is.False);

            flag1Choice.IsFlagged = true;

            Assert.That(flag1Choice.IsFlagged, Is.True);
            Assert.That(flag2Choice.IsFlagged, Is.True);
            Assert.That(flag3Choice.IsFlagged, Is.Null);
            Assert.That(flag4Choice.IsFlagged, Is.Null);
            Assert.That(flag5Choice.IsFlagged, Is.Null);
            Assert.That(vm.Value, Is.EqualTo(default(int)));

            var setValue = await editor.GetValueAsync <IReadOnlyList <int> > (p.Object);

            var setValue2 = await editor2.GetValueAsync <IReadOnlyList <int> > (p.Object);

            CollectionAssert.AreEquivalent(new[] { (int)FlagsTestEnum.Flag1, (int)FlagsTestEnum.Flag2, (int)FlagsTestEnum.Flag3 }, setValue.Value);
            CollectionAssert.AreEquivalent(new[] { (int)FlagsTestEnum.Flag1, (int)FlagsTestEnum.Flag2, (int)FlagsTestEnum.Flag4, (int)FlagsTestEnum.Flag5 }, setValue2.Value);
        }