public void Test_IResolvableToValue()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
DateTimeUtcNow dateTimeNow = new DateTimeUtcNow();
//---------------Test Result -----------------------
TestUtil.AssertIsInstanceOf<IResolvableToValue>(dateTimeNow);
}
public void Test_IResolvableToValue()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
DateTimeUtcNow dateTimeNow = new DateTimeUtcNow();
//---------------Test Result -----------------------
TestUtil.AssertIsInstanceOf <IResolvableToValue>(dateTimeNow);
}
public void Test_Equals_WithNull_ShouldReturnFalse()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
const DateTimeUtcNow dateTimeUtcNow2 = null;
//-------------Execute test ---------------------
bool result = dateTimeUtcNow.Equals(dateTimeUtcNow2);
//-------------Test Result ----------------------
Assert.IsFalse(result);
}
public void Test_Equals_WithDateTimeValue_ShouldReturnFalse()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
DateTime utcDateTime2 = DateTime.UtcNow;
//-------------Execute test ---------------------
bool result = dateTimeUtcNow.Equals(utcDateTime2);
//-------------Test Result ----------------------
Assert.IsFalse(result);
}
public void Test_Equals_WithDatetimeUtcNowType_ShouldReturnTrue()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
DateTimeUtcNow dateTimeUtcNow2 = new DateTimeUtcNow();
//-------------Execute test ---------------------
bool result = dateTimeUtcNow.Equals(dateTimeUtcNow2);
//-------------Test Result ----------------------
Assert.IsTrue(result);
}
public void Test_Comparable_Equals_WithDatetimeUtcNowType()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
IComparable comparable = dateTimeUtcNow;
//-------------Execute test ---------------------
int i = comparable.CompareTo(new DateTimeUtcNow());
//-------------Test Result ----------------------
Assert.AreEqual(0, i);
}
public void Test_Comparable_Equals_WithDatetimeUtcNowType()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
IComparable comparable = dateTimeUtcNow;
//-------------Execute test ---------------------
int i = comparable.CompareTo(new DateTimeUtcNow());
//-------------Test Result ----------------------
Assert.AreEqual(0, i);
}
public void Test_DataMapper_ParsePropValue_FromDateTimeUtcNowObject()
{
//---------------Set up test pack-------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object parsedValue;
bool parseSucceed = _dataMapper.TryParsePropValue(dateTimeUtcNow, out parsedValue);
//---------------Test Result -----------------------
Assert.IsTrue(parseSucceed);
Assert.AreSame(dateTimeUtcNow, parsedValue);
}
public void Test_Comparable_GreaterThan()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
IComparable comparable = dateTimeUtcNow;
DateTime dateTime = DateTimeUtcNow.Value.AddDays(-1);
//-------------Test Pre-conditions --------------
//-------------Execute test ---------------------
int i = comparable.CompareTo(dateTime);
//-------------Test Result ----------------------
Assert.AreEqual(1, i);
}
public void Test_Comparable_OfDateTime_LessThan()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
IComparable <DateTime> comparable = dateTimeUtcNow;
//-------------Test Pre-conditions --------------
//-------------Execute test ---------------------
int i = comparable.CompareTo(DateTimeUtcNow.Value.AddDays(1));
//-------------Test Result ----------------------
Assert.AreEqual(-1, i);
}
public void Test_Comparable_GreaterThan()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
IComparable comparable = dateTimeUtcNow;
DateTime dateTime = DateTimeUtcNow.Value.AddDays(-1);
//-------------Test Pre-conditions --------------
//-------------Execute test ---------------------
int i = comparable.CompareTo(dateTime);
//-------------Test Result ----------------------
Assert.AreEqual(1, i);
}
public void Test_ToString()
{
//---------------Set up test pack-------------------
DateTimeUtcNow dteNow = new DateTimeUtcNow();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
string toString = dteNow.ToString();
//---------------Test Result -----------------------
DateTime dteParsedDateTime;
Assert.IsTrue(DateTime.TryParse(toString, out dteParsedDateTime));
// Assert.IsTrue(dteNow == dteParsedDateTime);
Assert.AreEqual(toString, dteParsedDateTime.ToString());
}
public void Test_IResolvableToValue_ResolveToValue()
{
//---------------Set up test pack-------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
IResolvableToValue resolvableToValue = dateTimeUtcNow;
DateTime dateTimeBefore = DateTime.UtcNow;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object resolvedValue = resolvableToValue.ResolveToValue();
//---------------Test Result -----------------------
DateTime dateTimeAfter = DateTime.UtcNow;
DateTime dateTime = TestUtil.AssertIsInstanceOf<DateTime>(resolvedValue);
Assert.GreaterOrEqual(dateTime, dateTimeBefore);
Assert.LessOrEqual(dateTime, dateTimeAfter);
}
public void Test_DefaultTypeConverter_WithDateTime_ShouldReturnNowValue()
{
//---------------Set up test pack-------------------
TypeConverter typeConverter = TypeDescriptor.GetConverter(typeof(DateTimeUtcNow));
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
DateTime snapshot = DateTime.UtcNow;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object result = typeConverter.ConvertTo(dateTimeUtcNow, typeof(DateTime));
//---------------Test Result -----------------------
DateTime dateTime = TestUtil.AssertIsInstanceOf<DateTime>(result);
Assert.Greater(dateTime, snapshot.AddSeconds(-1));
Assert.Less(dateTime, snapshot.AddSeconds(1));
Assert.AreEqual(dateTime.Kind, DateTimeKind.Utc);
}
public void Test_IResolvableToValue_ResolveToValue()
{
//---------------Set up test pack-------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
IResolvableToValue resolvableToValue = dateTimeUtcNow;
DateTime dateTimeBefore = DateTime.UtcNow;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object resolvedValue = resolvableToValue.ResolveToValue();
//---------------Test Result -----------------------
DateTime dateTimeAfter = DateTime.UtcNow;
DateTime dateTime = TestUtil.AssertIsInstanceOf <DateTime>(resolvedValue);
Assert.GreaterOrEqual(dateTime, dateTimeBefore);
Assert.LessOrEqual(dateTime, dateTimeAfter);
}
public void Test_DefaultTypeConverter_WithDateTime_ShouldReturnNowValue()
{
//---------------Set up test pack-------------------
TypeConverter typeConverter = TypeDescriptor.GetConverter(typeof(DateTimeUtcNow));
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
DateTime snapshot = DateTime.UtcNow;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object result = typeConverter.ConvertTo(dateTimeUtcNow, typeof(DateTime));
//---------------Test Result -----------------------
DateTime dateTime = TestUtil.AssertIsInstanceOf <DateTime>(result);
Assert.Greater(dateTime, snapshot.AddSeconds(-1));
Assert.Less(dateTime, snapshot.AddSeconds(1));
Assert.AreEqual(dateTime.Kind, DateTimeKind.Utc);
}
public static int Main(string[] args)
{
DateTimeUtcNow utcNow = new DateTimeUtcNow();
TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.UtcNow property...");
if (utcNow.RunTests())
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("PASS");
return 100;
}
else
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("FAIL");
return 0;
}
}
public static int Main(string[] args)
{
DateTimeUtcNow utcNow = new DateTimeUtcNow();
TestLibrary.TestFramework.BeginTestCase("Testing System.DateTime.UtcNow property...");
if (utcNow.RunTests())
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("PASS");
return(100);
}
else
{
TestLibrary.TestFramework.EndTestCase();
TestLibrary.TestFramework.LogInformation("FAIL");
return(0);
}
}
///<summary>
/// Tries to parse a value as an object to a valid DateTimeValue or a resolvable DateTimeValue.
/// The valid value may not be a date but could instead return a <see cref="DateTimeToday"/> or <see cref="DateTimeNow"/> etc
/// These objects are convertable to DateTime via the <see cref="DateTimeToday.ResolveToValue"/>
///</summary>
///<param name="valueToParse"></param>
///<param name="returnValue"></param>
///<returns>If the value cannot be parsed to a valid date time then returns false else true</returns>
public static bool TryParseValue(object valueToParse, out object returnValue)
{
returnValue = null;
if (valueToParse != null && valueToParse is string && ((string)valueToParse).Length == 0)
{
return(true);
}
if (valueToParse == null || valueToParse == DBNull.Value)
{
return(true);
}
if (!(valueToParse is DateTime))
{
if (valueToParse is DateTimeToday || valueToParse is DateTimeNow || valueToParse is DateTimeUtcNow)
{
returnValue = valueToParse;
return(true);
}
if (valueToParse is String)
{
string stringValueToConvert = (string)valueToParse;
var stringValueToConvertUpperCase = stringValueToConvert.ToUpper();
if (stringValueToConvertUpperCase == "TODAY")
{
returnValue = new DateTimeToday();
return(true);
}
if (stringValueToConvertUpperCase == "YESTERDAY")
{
returnValue = new DateTimeToday();
((DateTimeToday)returnValue).OffSet = -1;
return(true);
}
if (stringValueToConvertUpperCase == "TOMORROW")
{
returnValue = new DateTimeToday();
((DateTimeToday)returnValue).OffSet = 1;
return(true);
}
if (stringValueToConvertUpperCase == "NOW")
{
returnValue = new DateTimeNow();
return(true);
}
if (stringValueToConvertUpperCase == "UTCNOW")
{
returnValue = new DateTimeUtcNow();
return(true);
}
DateTime dtOut;
if (DateTime.TryParseExact(stringValueToConvert, StandardDateTimeFormat, _dateTimeFormatProvider, DateTimeStyles.AllowWhiteSpaces, out dtOut))
{
returnValue = dtOut;
return(true);
}
}
DateTime dateTimeOut;
string valueToParseAsString = valueToParse.ToString();
if (DateTime.TryParse(valueToParseAsString, out dateTimeOut))
{
returnValue = dateTimeOut;
return(true);
}
if (DateTime.TryParse(valueToParseAsString, new DateTimeFormatInfo {
FullDateTimePattern = "dd/MM/yyyy HH:mm:ss:fff"
}, DateTimeStyles.AllowWhiteSpaces, out dateTimeOut))
{
returnValue = dateTimeOut;
return(true);
}
if (DateTime.TryParse(valueToParseAsString, new DateTimeFormatInfo {
FullDateTimePattern = "MM/dd/yyyy HH:mm:ss:fff"
}, DateTimeStyles.AllowWhiteSpaces, out dateTimeOut))
{
returnValue = dateTimeOut;
return(true);
}
return(false);
}
returnValue = valueToParse;
return(true);
}
public void Test_Equals_WithNull_ShouldReturnFalse()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
const DateTimeUtcNow dateTimeUtcNow2 = null;
//-------------Execute test ---------------------
bool result = dateTimeUtcNow.Equals(dateTimeUtcNow2);
//-------------Test Result ----------------------
Assert.IsFalse(result);
}
public void TestConvertValueToPropertyType_NowStringToDateTimeUtcNow_VariedCase()
{
//---------------Set up test pack-------------------
PropDef propDef = new PropDef("a", typeof (DateTime), PropReadWriteRule.ReadWrite, null);
const string dateTimeString = "utcNoW";
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
//---------------Execute Test ----------------------
object convertedDateTimeValue;
bool parsed = propDef.TryParsePropValue(dateTimeString, out convertedDateTimeValue);
//---------------Test Result -----------------------
Assert.IsTrue(parsed);
Assert.IsInstanceOf(typeof(DateTimeUtcNow), convertedDateTimeValue);
Assert.AreEqual(dateTimeUtcNow.ToString(), convertedDateTimeValue.ToString());
}
public void TestConvertValueToPropertyType_DateTimeAcceptsDateTimeUtcNow()
{
//---------------Set up test pack-------------------
PropDef propDef = new PropDef("a", typeof (DateTime), PropReadWriteRule.ReadWrite, null);
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
//---------------Execute Test ----------------------
object convertedDateTimeValue;
bool parsed = propDef.TryParsePropValue(dateTimeUtcNow, out convertedDateTimeValue);
//---------------Test Result -----------------------
Assert.IsTrue(parsed);
Assert.IsInstanceOf(typeof(DateTimeUtcNow), convertedDateTimeValue);
Assert.AreSame(dateTimeUtcNow, convertedDateTimeValue);
}
public void Test_Value_WhenDateTimeUtcNow_ShouldReturnResolvedValue()
{
//---------------Set up test pack-------------------
PropDef propDef = CreateTestPropDateTimePropDef(); ;
IBOProp boProp = propDef.CreateBOProp(true);
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
boProp.Value = dateTimeUtcNow;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object value = boProp.Value;
//---------------Test Result -----------------------
Assert.IsNotNull(value);
Assert.AreNotSame(dateTimeUtcNow, value);
}
public void Test_Equals_WithDateTimeValue_ShouldReturnFalse()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
DateTime utcDateTime2 = DateTime.UtcNow;
//-------------Execute test ---------------------
bool result = dateTimeUtcNow.Equals(utcDateTime2);
//-------------Test Result ----------------------
Assert.IsFalse(result);
}
public void Test_Equals_WithDatetimeUtcNowType_ShouldReturnTrue()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
DateTimeUtcNow dateTimeUtcNow2 = new DateTimeUtcNow();
//-------------Execute test ---------------------
bool result = dateTimeUtcNow.Equals(dateTimeUtcNow2);
//-------------Test Result ----------------------
Assert.IsTrue(result);
}
public void Test_ToString()
{
//---------------Set up test pack-------------------
DateTimeUtcNow dteNow = new DateTimeUtcNow();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
string toString = dteNow.ToString();
//---------------Test Result -----------------------
DateTime dteParsedDateTime;
Assert.IsTrue(DateTime.TryParse(toString, out dteParsedDateTime));
// Assert.IsTrue(dteNow == dteParsedDateTime);
Assert.AreEqual(toString, dteParsedDateTime.ToString());
}
///<summary>
/// Tries to parse a value as an object to a valid DateTimeValue or a resolvable DateTimeValue.
/// The valid value may not be a date but could instead return a <see cref="DateTimeToday"/> or <see cref="DateTimeNow"/> etc
/// These objects are convertable to DateTime via the <see cref="DateTimeToday.ResolveToValue"/>
///</summary>
///<param name="valueToParse"></param>
///<param name="returnValue"></param>
///<returns>If the value cannot be parsed to a valid date time then returns false else true</returns>
public static bool TryParseValue(object valueToParse, out object returnValue)
{
returnValue = null;
if (valueToParse != null && valueToParse is string && ((string)valueToParse).Length == 0) return true;
if(valueToParse == null || valueToParse == DBNull.Value) return true;
if (!(valueToParse is DateTime))
{
if (valueToParse is DateTimeToday || valueToParse is DateTimeNow || valueToParse is DateTimeUtcNow)
{
returnValue = valueToParse;
return true;
}
if (valueToParse is String)
{
string stringValueToConvert = (string)valueToParse;
var stringValueToConvertUpperCase = stringValueToConvert.ToUpper();
if (stringValueToConvertUpperCase == "TODAY")
{
returnValue = new DateTimeToday();
return true;
}
if (stringValueToConvertUpperCase == "YESTERDAY")
{
returnValue = new DateTimeToday();
((DateTimeToday) returnValue).OffSet = -1;
return true;
}
if (stringValueToConvertUpperCase == "TOMORROW")
{
returnValue = new DateTimeToday();
((DateTimeToday) returnValue).OffSet = 1;
return true;
}
if (stringValueToConvertUpperCase == "NOW")
{
returnValue = new DateTimeNow();
return true;
}
if (stringValueToConvertUpperCase == "UTCNOW")
{
returnValue = new DateTimeUtcNow();
return true;
}
DateTime dtOut;
if (DateTime.TryParseExact(stringValueToConvert, StandardDateTimeFormat, _dateTimeFormatProvider, DateTimeStyles.AllowWhiteSpaces, out dtOut))
{
returnValue = dtOut;
return true;
}
}
DateTime dateTimeOut;
string valueToParseAsString = valueToParse.ToString();
if (DateTime.TryParse(valueToParseAsString, out dateTimeOut))
{
returnValue = dateTimeOut;
return true;
}
if (DateTime.TryParse(valueToParseAsString, new DateTimeFormatInfo { FullDateTimePattern = "dd/MM/yyyy HH:mm:ss:fff" }, DateTimeStyles.AllowWhiteSpaces, out dateTimeOut))
{
returnValue = dateTimeOut;
return true;
}
if (DateTime.TryParse(valueToParseAsString, new DateTimeFormatInfo { FullDateTimePattern = "MM/dd/yyyy HH:mm:ss:fff" }, DateTimeStyles.AllowWhiteSpaces, out dateTimeOut))
{
returnValue = dateTimeOut;
return true;
}
return false;
}
returnValue = valueToParse;
return true;
}
public void Test_DataMapper_ParsePropValue_FromDateTimeUtcNowObject()
{
//---------------Set up test pack-------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object parsedValue;
bool parseSucceed = _dataMapper.TryParsePropValue(dateTimeUtcNow, out parsedValue);
//---------------Test Result -----------------------
Assert.IsTrue(parseSucceed);
Assert.AreSame(dateTimeUtcNow, parsedValue);
}
public void TestIsMatch_DateTimeUtcNow_LessThan_NoMatch()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
ContactPersonTestBO.LoadDefaultClassDef();
ContactPersonTestBO cp = new ContactPersonTestBO();
cp.Surname = Guid.NewGuid().ToString("N");
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
cp.DateOfBirth = DateTime.Today.AddDays(1);
//---------------Assert PreConditions---------------
//---------------Execute Test ----------------------
Criteria criteria = new Criteria("DateOfBirth", Criteria.ComparisonOp.LessThan, dateTimeUtcNow);
bool isMatch = criteria.IsMatch(cp);
//---------------Test Result -----------------------
Assert.IsFalse(isMatch, "The object should not be a match since it does not match the criteria given.");
//---------------Tear Down -------------------------
}
public void Test_Comparable_OfDateTime_LessThan()
{
//-------------Setup Test Pack ------------------
DateTimeUtcNow dateTimeUtcNow = new DateTimeUtcNow();
IComparable<DateTime> comparable = dateTimeUtcNow;
//-------------Test Pre-conditions --------------
//-------------Execute test ---------------------
int i = comparable.CompareTo(DateTimeUtcNow.Value.AddDays(1));
//-------------Test Result ----------------------
Assert.AreEqual(-1, i);
}
