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