public void Configuration_Null_Configurator_Throws_NullArgumentException()
{
// Arrange
// Act
TestDelegate test = () => FormatterContainer.Create(null);
// Assert
Assert.That(test, Throws.ArgumentNullException);
}
public void NullableValueTypesFormatNull_ThrowArgumentNullException_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.NullableValueTypesFormatNull = NullFormatHandling.ThrowArgumentNullException;
});
// Act
TestDelegate test = () => formatter.For <int?>().Format(null);
// Assert
Assert.That(test, Throws.TypeOf <ArgumentNullException>());
}
public void FormatSpecific_String_Func_Can_Replace_Default(string input, string expected)
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.UseFunc <string>(s => s.ToUpper(), (s, f) => s.ToUpper());
});
// Act
string result = formatter.For <string>().Format("hello?");
// Assert
Assert.That(result, Is.EqualTo("HELLO?"));
}
public void ReferenceTypesFormatNullToNull_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.ReferenceTypesFormatNullToNull = true;
});
// Act
string result = formatter.For <TestClass>().Format(null);
// Assert
Assert.That(result, Is.Null);
}
public void NullableValueTypesFormatNull_ReturnEmptyString_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.NullableValueTypesFormatNull = NullFormatHandling.ReturnEmptyString;
});
// Act
string result = formatter.For <int?>().Format(null);
// Assert
Assert.That(result, Is.EqualTo(""));
}
public void MissingFormatSpecific_UseToString_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.MissingFormatSpecific = MissingFormatSpecificHandling.UseToString;
});
var input = new TestClassWithoutFormatSpecific("anything");
// Act
string result = formatter.For <TestClassWithoutFormatSpecific>().Format(input, null);
// Assert
Assert.That(result, Is.EqualTo("anything"));
}
public void Format_Uses_Configured_Type_Converter(string input)
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.UseTypeConverter <TestClassWithTypeConverter>();
});
TestClassWithTypeConverter obj = new TestClassWithTypeConverter(input);
// Act
string result = formatter.For <TestClassWithTypeConverter>().Format(obj);
// Assert
Assert.That(result, Is.EqualTo(input));
}
public void Configuration_Rejects_FormatFunc_For_NullableValueType()
{
// Arrange
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseFunc <int?>(v => "");
});
};
// Assert
}
public void MissingFormatSpecific_ThrowNotSupportedException_Option()
{
// Arrange
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.MissingFormatSpecific = MissingFormatSpecificHandling.ThrowNotSupportedException;
});
var input = new TestClassWithoutFormatSpecific("anything");
// Act
TestDelegate test = () => formatter.For <TestClassWithoutFormatSpecific>().Format(input, null);
// Assert
Assert.That(test, Throws.TypeOf <NotSupportedException>());
}
public void Configuration_Rejects_FormatFunc_For_Delegate()
{
// Arrange
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseFunc <Func <int> >(v => "");
});
};
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_Null_FormatterObject_Throws_NullArgumentException()
{
// Arrange
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseFormatterObject <int>(null);
});
};
// Assert
Assert.That(test, Throws.ArgumentNullException);
}
public void Configuration_NullableValueTypesFormatNull_Throws_If_Configuration_Locked()
{
// Arrange
FormatterConfiguration outerConfig = null;
FormatterContainer.Create(config =>
{
outerConfig = config;
});
// Act
TestDelegate test = () => outerConfig.NullableValueTypesFormatNull = NullFormatHandling.ReturnEmptyString;
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_UseTypeConverter_Throws_If_Configuration_Locked()
{
// Arrange
FormatterConfiguration outerConfig = null;
FormatterContainer.Create(config =>
{
outerConfig = config;
});
// Act
TestDelegate test = () => outerConfig.UseTypeConverter <string>();
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_ReferenceTypesFormatNullToNull_Throws_If_Configuration_Locked()
{
// Arrange
FormatterConfiguration outerConfig = null;
FormatterContainer.Create(config =>
{
outerConfig = config;
});
// Act
TestDelegate test = () => outerConfig.ReferenceTypesFormatNullToNull = true;
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_MissingFormatSpecific_Throws_If_Configuration_Locked()
{
// Arrange
FormatterConfiguration outerConfig = null;
FormatterContainer.Create(config =>
{
outerConfig = config;
});
// Act
TestDelegate test = () => outerConfig.MissingFormatSpecific = MissingFormatSpecificHandling.ReturnEmptyString;
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_Rejects_Mix_Of_Default_And_TypeConverter()
{
// Arrange
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseDefault <int>();
config.UseTypeConverter <int>();
});
};
// Assert
}
public void Configuration_Rejects_Mix_Of_Default_And_FormatterObject()
{
// Arrange
Mock <IFormatter <int> > formatterObjectMock = new Mock <IFormatter <int> >();
IFormatter <int> formatterObject = formatterObjectMock.Object;
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseDefault <int>();
config.UseFormatterObject(formatterObject);
});
};
// Assert
}
public void Configuration_Rejects_FormatterObject_For_Interface()
{
// Arrange
Mock <IFormatter <IFormattable> > formatterObjectMock = new Mock <IFormatter <IFormattable> >();
IFormatter <IFormattable> formatterObject = formatterObjectMock.Object;
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseFormatterObject(formatterObject);
});
};
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Configuration_Rejects_Mix_Of_TypeConverter_And_FormatterObject()
{
// Arrange
Mock <IFormatter <int> > formatterObjectMock = new Mock <IFormatter <int> >();
IFormatter <int> formatterObject = formatterObjectMock.Object;
// Act
TestDelegate test = () =>
{
FormatterContainer.Create(config =>
{
config.UseTypeConverter <int>();
config.UseFormatterObject(formatterObject);
});
};
// Assert
Assert.That(test, Throws.TypeOf <OsmoticConfigurationException>());
}
public void Format_FormatSpecific_String_FormatterObject_Can_Replace_Default(string input, string expected)
{
// Arrange
Mock <IFormatter <string> > stringFormatterMock = new Mock <IFormatter <string> >();
stringFormatterMock.Setup(m => m.Format(It.IsAny <string>()))
.Returns(new FormatReturns <string>(s => s.ToUpper()));
stringFormatterMock.Setup(m => m.Format(It.IsAny <string>(), It.IsAny <string>()))
.Returns(new FormatSpecificReturns <string>((s, f) => s.ToUpper()));
FormatterContainer formatter = FormatterContainer.Create(config =>
{
config.UseFormatterObject(stringFormatterMock.Object);
});
// Act
string result1 = formatter.For <string>().Format(input);
string result2 = formatter.For <string>().Format(input, null);
// Assert
Assert.That(result1, Is.EqualTo(expected));
Assert.That(result2, Is.EqualTo(expected));
}
