public void BoolToVisibilityConverterTest()
        {
            BoolToVisibilityConverter converter = new BoolToVisibilityConverter();

            Assert.AreEqual(Visibility.Collapsed, converter.Convert(false, null, null, null));
            Assert.AreEqual(Visibility.Visible, converter.Convert(true, null, null, null));
        }
Exemple #2
0
        public void ConvertTest()
        {
            var target = new BoolToVisibilityConverter();

            Assert.AreEqual(Visibility.Visible, target.Convert(true, null, null, null));
            Assert.AreEqual(Visibility.Collapsed, target.Convert(false, null, null, null));
        }
Exemple #3
0
        public void Convert_NullValue_NullNegateValue()
        {
            BoolToVisibilityConverter converter = new BoolToVisibilityConverter();
            Visibility visibility = (Visibility)converter.Convert(null, typeof(Visibility), null, null);

            Assert.IsTrue(visibility == Visibility.Collapsed);

            visibility = (Visibility)converter.Convert((bool?)null, typeof(Visibility), null, null);
            Assert.IsTrue(visibility == Visibility.Collapsed);
        }
Exemple #4
0
        public void BoolToVisibilityConvertTest()
        {
            var converter = new BoolToVisibilityConverter();

            Assert.That(
                converter.Convert(false, typeof(Visibility), null, CultureInfo.CurrentUICulture)
                .Equals(Visibility.Visible));
            Assert.That(
                converter.Convert(true, typeof(Visibility), null, CultureInfo.CurrentUICulture)
                .Equals(Visibility.Collapsed));
        }
Exemple #5
0
        public void Convert_NullValue_TrueNegateValue()
        {
            foreach (object truthinessObject in _trueValues)
            {
                BoolToVisibilityConverter converter = new BoolToVisibilityConverter();
                Visibility visibility = (Visibility)converter.Convert(null, typeof(Visibility), truthinessObject, null);
                Assert.IsTrue(visibility == Visibility.Visible);

                visibility = (Visibility)converter.Convert((bool?)null, typeof(Visibility), truthinessObject, null);
                Assert.IsTrue(visibility == Visibility.Visible);
            }
        }
        public void BoolToVisibility_Inverted_ReturnsCorrectResult()
        {
            var btv = new BoolToVisibilityConverter { InvertVisibility = true };
            Assert.AreEqual(Visibility.Visible, btv.Convert(false, typeof(Visibility), null, null));
            Assert.AreEqual(Visibility.Collapsed, btv.Convert(true, typeof(Visibility), null, null));
            Assert.AreEqual(false, btv.ConvertBack(Visibility.Visible, typeof(bool), null, null));
            Assert.AreEqual(true, btv.ConvertBack(Visibility.Hidden, typeof(bool), null, null));

            btv.NotVisibleValue = Visibility.Hidden;
            Assert.AreEqual(Visibility.Hidden, btv.Convert(true, typeof(Visibility), null, null));
            Assert.AreEqual(false, btv.ConvertBack(Visibility.Visible, typeof(bool), null, null));
            Assert.AreEqual(true, btv.ConvertBack(Visibility.Hidden, typeof(bool), null, null));
        }
Exemple #7
0
        /// <summary>
        /// Tests the converter when converting a false value and specifically not negating that value
        /// </summary>
        public void Convert_FalseValue_FalseNegateValue()
        {
            bool boolVal         = false;
            bool?nullableBoolVal = false;

            BoolToVisibilityConverter converter = new BoolToVisibilityConverter();
            Visibility visibility = (Visibility)converter.Convert(boolVal, typeof(Visibility), false, null);

            Assert.IsTrue(visibility == Visibility.Collapsed);

            visibility = (Visibility)converter.Convert(nullableBoolVal, typeof(Visibility), false, null);
            Assert.IsTrue(visibility == Visibility.Collapsed);
        }
        public void ShouldConvertToVisibility()
        {
            BoolToVisibilityConverter converter = new BoolToVisibilityConverter();

            object value          = true;
            var    convertedValue = converter.Convert(value, typeof(bool), null, null) as Visibility?;

            Assert.AreEqual(Visibility.Visible, convertedValue);

            value          = false;
            convertedValue = converter.Convert(value, typeof(bool), null, null) as Visibility?;
            Assert.AreEqual(Visibility.Hidden, convertedValue);
        }
Exemple #9
0
        public void Convert_TrueValue_NullNegateValue()
        {
            bool boolVal         = true;
            bool?nullableBoolVal = true;

            BoolToVisibilityConverter converter = new BoolToVisibilityConverter();
            Visibility visibility = (Visibility)converter.Convert(boolVal, typeof(Visibility), null, null);

            Assert.IsTrue(visibility == Visibility.Visible);

            visibility = (Visibility)converter.Convert(nullableBoolVal, typeof(Visibility), null, null);
            Assert.IsTrue(visibility == Visibility.Visible);
        }
Exemple #10
0
        public void Convert_TrueValue_TrueNegateValue()
        {
            foreach (object truthinessObject in _trueValues)
            {
                bool boolVal         = true;
                bool?nullableBoolVal = true;

                BoolToVisibilityConverter converter = new BoolToVisibilityConverter();
                Visibility visibility = (Visibility)converter.Convert(boolVal, typeof(Visibility), truthinessObject, null);
                Assert.IsTrue(visibility == Visibility.Collapsed);

                visibility = (Visibility)converter.Convert(nullableBoolVal, typeof(Visibility), truthinessObject, null);
                Assert.IsTrue(visibility == Visibility.Collapsed);
            }
        }
Exemple #11
0
        public void BoolToVisibility_Inverted_ReturnsCorrectResult()
        {
            var btv = new BoolToVisibilityConverter {
                InvertVisibility = true
            };

            Assert.AreEqual(Visibility.Visible, btv.Convert(false, typeof(Visibility), null, null));
            Assert.AreEqual(Visibility.Collapsed, btv.Convert(true, typeof(Visibility), null, null));
            Assert.AreEqual(false, btv.ConvertBack(Visibility.Visible, typeof(bool), null, null));
            Assert.AreEqual(true, btv.ConvertBack(Visibility.Hidden, typeof(bool), null, null));

            btv.NotVisibleValue = Visibility.Hidden;
            Assert.AreEqual(Visibility.Hidden, btv.Convert(true, typeof(Visibility), null, null));
            Assert.AreEqual(false, btv.ConvertBack(Visibility.Visible, typeof(bool), null, null));
            Assert.AreEqual(true, btv.ConvertBack(Visibility.Hidden, typeof(bool), null, null));
        }
        public void Convert_InvalidCastException_value()
        {
            // Arrange
            var converter = new BoolToVisibilityConverter();

            // Act
            converter.Convert(2.0, null, null, null);
        }
        public void Convert_InvalidCastException_parameter()
        {
            // Arrange
            var converter = new BoolToVisibilityConverter();

            // Act
            converter.Convert(true, null, 2.0, null);
        }
        public void Convert_ArgumentNullException_Value()
        {
            // Arrange
            IValueConverter converter = new BoolToVisibilityConverter();

            // Act & Assert
            Assert.Throws <ArgumentNullException>(() => converter.Convert(null, typeof(Visibility), null, CultureInfo.InvariantCulture));
        }
        public void Convert_Arrange_Value_TargetType_Parameter_CultureInfoIsNull_ExpectedBoolToVisibilityConverterNullValueExceptionThrown(bool?arrangedValue,
                                                                                                                                           Type arrangedTargetType, object arrangedParameter)
        {
            var btvConverter = new BoolToVisibilityConverter();

            Assert.Throws <BoolToVisibilityConverterNullValueException>(() => btvConverter.Convert(arrangedValue,
                                                                                                   arrangedTargetType, arrangedParameter, CultureInfo.CurrentCulture));
        }
        public void Convert_ArgumentException_InvalidTargetType()
        {
            // Arrange
            IValueConverter converter = new BoolToVisibilityConverter();

            // Act & Assert
            Assert.Throws <ArgumentException>(() => converter.Convert(true, typeof(long), null, CultureInfo.InvariantCulture));
        }
        public void BoolToVisibilityConverter_Convert_NonBoolInput_ThrowsArgumentException()
        {
            var converter = new BoolToVisibilityConverter();

            Action act = () => converter.Convert("NotABoolean", typeof(Visibility), null, CultureInfo.InvariantCulture);

            act.Should().Throw <ArgumentException>();
        }
        public void Convert(object input, Type targetType, object parameter, string cultureString, object expectedOutput)
        {
            var converter = new BoolToVisibilityConverter();
            var culture   = new CultureInfo(cultureString);
            var output    = converter.Convert(input, targetType, parameter, culture);

            Assert.Equal(expectedOutput, output);
        }
        public void BoolToVisibilityConverter_Convert_NonVisibilityOutput_ThrowsArgumentException()
        {
            var converter         = new BoolToVisibilityConverter();
            var notVisibilityType = typeof(string);

            Action act = () => converter.Convert(true, notVisibilityType, null, CultureInfo.InvariantCulture);

            act.Should().Throw <ArgumentException>();
        }
        public void Convert_WhenValueArgumentIsNotBool_ShouldThrow()
        {
            // Arrange
            var converter = new BoolToVisibilityConverter();

            // Act, Assert
            Should.Throw <ArgumentException>(() => converter.Convert("random" as object, null, null, null))
            .Message.ShouldBe("Wrong data type. Expected a boolean");
        }
Exemple #21
0
        public void BoolToVisibilityConverter_Convert()
        {
            var converter = new BoolToVisibilityConverter();

            var convertedValue = (Visibility) converter.Convert(true, typeof(Visibility), null, CultureInfo.CurrentCulture);

            Assert.IsNotNull(convertedValue);
            Assert.AreEqual(Visibility.Visible, convertedValue);
        }
Exemple #22
0
        public void BoolToVisibilityConverter_Convert_NonBoolInput_ThrowsArgumentException()
        {
            var converter = new BoolToVisibilityConverter();

            Exceptions.Expect <ArgumentException>(() =>
            {
                converter.Convert("NotABoolean", typeof(Visibility), null, CultureInfo.InvariantCulture);
            });
        }
        public void Convert_Arrange_Value_TargetType_Parameter_CultureInfoIsNull_ExpectedVisibility(bool arrangedValue,
                                                                                                    Type arrangedTargetType, object arrangedParameter, Visibility expectedVisibility)
        {
            var btvConverter     = new BoolToVisibilityConverter();
            var actualVisibility = btvConverter.Convert(arrangedValue,
                                                        arrangedTargetType, arrangedParameter, null);

            Assert.AreEqual(expectedVisibility, actualVisibility);
        }
Exemple #24
0
        public void BoolToVisibilityConverter_Convert_NonVisibilityOutput_ThrowsArgumentException()
        {
            var converter         = new BoolToVisibilityConverter();
            var notVisibilityType = typeof(string);

            Exceptions.Expect <ArgumentException>(() =>
            {
                converter.Convert(true, notVisibilityType, null, CultureInfo.InvariantCulture);
            });
        }
        public void Convert_returns_DependencyPropertyUnsetValue_when_value_null()
        {
            var converter = new BoolToVisibilityConverter();
            var culture   = new CultureInfo("en-US");

#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
            var output = converter.Convert(null, typeof(Visibility), null, culture);
#pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
            Assert.Equal(DependencyProperty.UnsetValue, output);
        }
Exemple #26
0
        public void Convert_PassedFalse_ShouldReturnCollapsed()
        {
            // Arrange/Act
            var converter = new BoolToVisibilityConverter();

            // Act
            var result = converter.Convert(false, typeof(Visibility), null, CultureInfo.CurrentCulture);

            // Assert
            Assert.Equal(Visibility.Collapsed, result);
        }
Exemple #27
0
        public void Convert_PassedTrue_ShouldReturnVisible()
        {
            // Arrange/Act
            var converter = new BoolToVisibilityConverter();

            // Act
            var result = converter.Convert(true, typeof(Visibility), null, CultureInfo.CurrentCulture);

            // Assert
            Assert.Equal(Visibility.Visible, result);
        }
Exemple #28
0
        public void Convert_PassedUnknownValue_ShouldReturnNull()
        {
            // Arrange/Act
            var converter = new BoolToVisibilityConverter();

            // Act
            var result = converter.Convert(String.Empty, typeof(Visibility), null, CultureInfo.CurrentCulture);

            // Assert
            Assert.Null(result);
        }
        public void Should_Return_Null_If_Converting_From_Boolean_To_Anything_Other_Than_Visibility()
        {
            // Given
            var converter = new BoolToVisibilityConverter();

            // When
            var result = converter.Convert("Hello", null, null, null);

            // Then
            Assert.Null(result);
        }
        public void Convert_CollapsedToVisible()
        {
            // Arrange
            var converter = new BoolToVisibilityConverter();

            // Act
            var result = converter.Convert(false, null, "invert", null);

            // Assert
            Assert.AreEqual(Visibility.Visible, result);
        }
        public void Convert_VisibleToCollapsed()
        {
            // Arrange
            var converter = new BoolToVisibilityConverter();

            // Act
            var result = converter.Convert(true, null, "invert", null);

            // Assert
            Assert.AreEqual(Visibility.Collapsed, result);
        }