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));
}
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 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);
}
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");
}
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");
}
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);
}
