public void ConvertWithEmptyValuesShouldReturnTypesDefault(
     int index)
 {
     var converter = new AlternationConverter<int>();
     var asNonGeneric = converter as IValueConverter;
     Assert.Equal(0, converter.Convert(index, CultureInfo.InvariantCulture));
     Assert.Equal(0, asNonGeneric.Convert(index, typeof(int), null, CultureInfo.InvariantCulture));
 }
        public void ConvertWithSingleValueShouldAlwaysReturnIt(
            int index)
        {
            var converter = new AlternationConverter<int>();
            converter.Values.Add(42);

            var asNonGeneric = converter as IValueConverter;

            Assert.Equal(42, converter.Convert(index, CultureInfo.InvariantCulture));

            Assert.Equal(42, asNonGeneric.Convert(index, typeof(int), null, CultureInfo.InvariantCulture));
        }
        public void ConvertWithTwoValuesShouldAlternateThose(
            int index,
            bool expected)
        {
            var converter = new AlternationConverter<bool>();
            converter.Values.Add(true);
            converter.Values.Add(false);

            var asNonGeneric = converter as IValueConverter;

            Assert.Equal(expected, converter.Convert(index, CultureInfo.InvariantCulture));
            Assert.Equal(expected, asNonGeneric.Convert(index, typeof(bool), null, CultureInfo.InvariantCulture));
        }
Esempio n. 4
0
        private void InitPalette()
        {
            var brushes = from prop in typeof(Brushes).GetProperties()
                          let brush = (SolidColorBrush)prop.GetValue(null, null)
                                      let hsbColor = HsbColor.FromArgbColor(brush.Color)
                                                     orderby hsbColor.Hue
                                                     select new SolidColorBrush(hsbColor.ToArgbColor());

            AlternationConverter converter = new AlternationConverter();

            foreach (var brush in brushes)
            {
                converter.Values.Add(brush);
            }

            Resources.Add("fillsConverter", converter);
        }
        public void ConvertWithThreeValuesWorksAsExpected(
            int index,
            Visibility expected)
        {
            var converter = new AlternationConverter<Visibility>();
            converter.Values.Add(Visibility.Visible);
            converter.Values.Add(Visibility.Collapsed);
            converter.Values.Add(Visibility.Hidden);

            var asNonGeneric = converter as IValueConverter;

            Assert.Equal(
                expected,
                converter.Convert(index, CultureInfo.InvariantCulture));

            Assert.Equal(
                expected,
                asNonGeneric.Convert(index, typeof(Visibility), null, CultureInfo.InvariantCulture));
        }
        public void ConvertBackWorksAsExpected(
            Visibility value,
            int expectedIndex)
        {
            var converter = new AlternationConverter<Visibility>();
            converter.Values.Add(Visibility.Visible);
            converter.Values.Add(Visibility.Collapsed);
            converter.Values.Add(Visibility.Hidden);

            Assert.Equal(expectedIndex, converter.ConvertBack(value, CultureInfo.InvariantCulture));
        }
 public void ConvertBackWithValueNotFoundShouldReturnMinus1(
     Visibility value)
 {
     var converter = new AlternationConverter<Visibility>();
     Assert.Equal(-1, converter.ConvertBack(value, CultureInfo.InvariantCulture));
 }