public void can_convert_from_standard_format()
{
TimeSpanConverter.GetTimeSpan("00:00:01").ShouldEqual(new TimeSpan(0, 0, 1));
TimeSpanConverter.GetTimeSpan("00:10:00").ShouldEqual(new TimeSpan(0, 10, 0));
TimeSpanConverter.GetTimeSpan("01:30:00").ShouldEqual(new TimeSpan(1, 30, 0));
TimeSpanConverter.GetTimeSpan("1.01:30:00").ShouldEqual(new TimeSpan(1, 1, 30, 0));
TimeSpanConverter.GetTimeSpan("-00:10:00").ShouldEqual(new TimeSpan(0, -10, 0));
TimeSpanConverter.GetTimeSpan("12:34:56.789").ShouldEqual(new TimeSpan(0, 12, 34, 56, 789));
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// timespanconverter.ConvertTo<int>(context, culture, value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this TimeSpanConverter timespanconverter, ITypeDescriptorContext context, System.Globalization.CultureInfo culture, Object value)
{
if (timespanconverter == null)
{
throw new ArgumentNullException("timespanconverter");
}
return((T)timespanconverter.ConvertTo(context, culture, value, typeof(T)));
}
public override void Start(Game game)
{
ding = CodecFactory.Instance.GetCodec(pathToSelectDing).ChangeSampleRate(AudioManager.sampleRate).ToStereo().ToSampleSource();
spanConverter = new TimeSpanConverter();
//ImageUtils.BMPToBinary(Path.Combine(Program.contentPath, "MenuMusic", "HVMusic", "bitmaps"), Path.Combine(Program.contentPath, "MenuMusic", "vidR.cvid"));
video = new HVVideo();
game.addGameObject(video);
}
public void ParseTimeSpan_WithTimeSpanNoFormatString_ParsesTimeSpan()
{
var expected = new TimeSpan(0, 0, 12);
var input = "12";
var converter = new TimeSpanConverter();
var actual = converter.ConvertFromInvariantString(input);
Assert.AreEqual(expected, actual);
}
public void ParseTimeSpan_WithStandardTimeSpanString_ParsesTimeSpan()
{
var expected = new TimeSpan(12, 15, 10);
var input = "12:15:10";
var converter = new TimeSpanConverter();
var actual = converter.ConvertFromInvariantString(input);
Assert.AreEqual(expected, actual);
}
public void HandleTimeSpans()
{
TimeSpan input = new TimeSpan(12220);
var converter = new TimeSpanConverter();
var result = converter.Convert(input);
Assert.Equal(1.22, result);
}
public void HandleNullableTimeSpansWithNoValue()
{
TimeSpan?input = null;
var converter = new TimeSpanConverter();
var result = converter.Convert(input);
Assert.Null(result);
}
public void ConvertTimeSpan_WithNegativeTimeSpanSecondsInput_ParsesTimeSpan()
{
var expected = new TimeSpan(0, 0, -12);
const string input = "-12s";
var converter = new TimeSpanConverter();
var actual = converter.ConvertFromInvariantString(input);
Assert.AreEqual(expected, actual);
}
protected override void PostTestInit(object sender, PluginEventArgs e)
{
RetryFailedRequestsInfo retryFailedRequestsInfo = GetRetryFailedRequestsInfo(e.TestMethodMemberInfo);
if (retryFailedRequestsInfo != null)
{
var client = e.Container.Resolve <ApiClientService>();
client.PauseBetweenFailures = TimeSpanConverter.Convert(retryFailedRequestsInfo.PauseBetweenFailures, retryFailedRequestsInfo.TimeUnit);
client.MaxRetryAttempts = retryFailedRequestsInfo.MaxRetryAttempts;
}
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
try
{
var converter = new TimeSpanConverter();
return(converter.ConvertFrom(value));
}
catch
{
return(value);//can't convert, let databinding try to handle it
}
}
public void TargetType()
{
// Arrange
IConverter converter = new TimeSpanConverter();
var expectedType = typeof(TimeSpan);
// Act
var actualType = converter.TargetType;
// Assert
Assert.Equal(expectedType, actualType);
}
public void Can_deserialize_TimeSpan()
{
Assert.That(TimeSpanConverter.FromXsdDuration("P1D"), Is.EqualTo(new TimeSpan(1, 0, 0, 0)));
Assert.That(TimeSpanConverter.FromXsdDuration("PT1H"), Is.EqualTo(new TimeSpan(1, 0, 0)));
Assert.That(TimeSpanConverter.FromXsdDuration("PT1M"), Is.EqualTo(new TimeSpan(0, 1, 0)));
Assert.That(TimeSpanConverter.FromXsdDuration("PT1S"), Is.EqualTo(new TimeSpan(0, 0, 1)));
Assert.That(TimeSpanConverter.FromXsdDuration("PT0.001S"), Is.EqualTo(new TimeSpan(0, 0, 0, 0, 1)));
Assert.That(TimeSpanConverter.FromXsdDuration("P1DT1H1M1.001S"), Is.EqualTo(new TimeSpan(1, 1, 1, 1, 1)));
Assert.That(TimeSpanConverter.FromXsdDuration("PT0.0000001S"), Is.EqualTo(new TimeSpan(1)));
Assert.That(TimeSpanConverter.FromXsdDuration("PT0S"), Is.EqualTo(TimeSpan.Zero));
Assert.That(TimeSpanConverter.FromXsdDuration("P3650D"), Is.EqualTo(TimeSpan.FromDays(3650)));
}
private static void InitConverters()
{
Converters = new Dictionary <Type, Func <string, object> >();
Converters[typeof(String)] = x => x;
Converters[typeof(Double)] = x => Double.Parse(x);
Converters[typeof(Int32)] = x => Int32.Parse(x);
Converters[typeof(Int64)] = x => Int64.Parse(x);
Converters[typeof(IPAddress)] = IPAddress.Parse;
Converters[typeof(TimeSpan)] = new TimeSpanConverter().ConvertFrom;
Converters[typeof(DateTime)] = new DateTimeConverter().ConvertFrom;
Converters[typeof(Boolean)] = s => Boolean.Parse(s);
Converters[typeof(UInt16)] = s => UInt16.Parse(s);
}
public void Can_Serialize_TimeSpan()
{
Assert.That(TimeSpanConverter.ToXsdDuration(new TimeSpan(1, 0, 0, 0)), Is.EqualTo("P1D"));
Assert.That(TimeSpanConverter.ToXsdDuration(new TimeSpan(1, 0, 0)), Is.EqualTo("PT1H"));
Assert.That(TimeSpanConverter.ToXsdDuration(new TimeSpan(0, 1, 0)), Is.EqualTo("PT1M"));
Assert.That(TimeSpanConverter.ToXsdDuration(new TimeSpan(0, 0, 1)), Is.EqualTo("PT1S"));
Assert.That(TimeSpanConverter.ToXsdDuration(new TimeSpan(0, 0, 0, 0, 1)), Is.EqualTo("PT0.001S"));
Assert.That(TimeSpanConverter.ToXsdDuration(new TimeSpan(1, 1, 1, 1, 1)), Is.EqualTo("P1DT1H1M1.001S"));
Assert.That(TimeSpanConverter.ToXsdDuration(new TimeSpan(1)), Is.EqualTo("PT0.0000001S"));
Assert.That(TimeSpanConverter.ToXsdDuration(TimeSpan.Zero), Is.EqualTo("PT0S"));
Assert.That(TimeSpanConverter.ToXsdDuration(new DateTime(2010, 1, 1) - new DateTime(2000, 1, 1)), Is.EqualTo("P3653D"));
}
/// <summary>
/// Registers standard and configured type converters.
/// </summary>
static TypeConverterRegistry()
{
lock (_syncRoot)
{
_converters[typeof(string[])] = new StringArrayConverter();
_converters[typeof(Type)] = new RuntimeTypeConverter();
_converters[typeof(Uri)] = new UriConverter();
_converters[typeof(FileInfo)] = new FileInfoConverter();
_converters[typeof(NameValueCollection)] = new NameValueConverter();
_converters[typeof(Regex)] = new RegexConverter();
_converters[typeof(TimeSpan)] = new TimeSpanConverter();
}
}
private JsonFxAOT()
{
TypeConverter c;
c = new ArrayConverter();
m_fakeFlag = c.Equals(c);
//c = new BaseNumberConverter();
//m_fakeFlag = c.Equals(c);
c = new BooleanConverter();
m_fakeFlag = c.Equals(c);
c = new ByteConverter();
m_fakeFlag = c.Equals(c);
c = new CollectionConverter();
m_fakeFlag = c.Equals(c);
c = new ComponentConverter(typeof(int));
m_fakeFlag = c.Equals(c);
c = new CultureInfoConverter();
m_fakeFlag = c.Equals(c);
c = new DateTimeConverter();
m_fakeFlag = c.Equals(c);
c = new DecimalConverter();
m_fakeFlag = c.Equals(c);
c = new DoubleConverter();
m_fakeFlag = c.Equals(c);
c = new EnumConverter(typeof(int));
m_fakeFlag = c.Equals(c);
c = new ExpandableObjectConverter();
m_fakeFlag = c.Equals(c);
c = new Int16Converter();
m_fakeFlag = c.Equals(c);
c = new Int32Converter();
m_fakeFlag = c.Equals(c);
c = new Int64Converter();
m_fakeFlag = c.Equals(c);
c = new NullableConverter(typeof(object));
m_fakeFlag = c.Equals(c);
c = new SByteConverter();
m_fakeFlag = c.Equals(c);
c = new SingleConverter();
m_fakeFlag = c.Equals(c);
c = new StringConverter();
m_fakeFlag = c.Equals(c);
c = new TimeSpanConverter();
m_fakeFlag = c.Equals(c);
c = new UInt16Converter();
m_fakeFlag = c.Equals(c);
c = new UInt32Converter();
m_fakeFlag = c.Equals(c);
c = new UInt64Converter();
m_fakeFlag = c.Equals(c);
}
public void GetTimeSpansFromDayPeriod_For_UK_PM_Test()
{
const string input = "Europe/London";
var timeZones = TimeSpanConverter.GetTimeSpansFromDayPeriod(DayPeriods.Pm, input);
var from = new DateTime(timeZones[0].From);
var to = new DateTime(timeZones[0].To);
timeZones.Count.Should().Be(1);
from.TimeOfDay.Should().BeLessThan(to.TimeOfDay);
from.TimeOfDay.Should().Be(GetDateTimeToUtc(new DateTime(1, 1, 1, 12, 0, 0), input).TimeOfDay);
to.TimeOfDay.Should().Be(GetDateTimeToUtc(new DateTime(1, 1, 1, 23, 59, 59), input).TimeOfDay);
}
protected override void PostBeforeScenario(object sender, TestWorkflowPluginEventArgs e)
{
var retryFailedRequestsInfo = new RetryFailedRequestsInfo()
{
MaxRetryAttempts = _maxRetryAttempts,
PauseBetweenFailures = _pauseBetweenFailures,
TimeUnit = _timeUnit,
};
var client = ServicesCollection.Current.Resolve <ApiClientService>();
client.PauseBetweenFailures = TimeSpanConverter.Convert(retryFailedRequestsInfo.PauseBetweenFailures, retryFailedRequestsInfo.TimeUnit);
client.MaxRetryAttempts = retryFailedRequestsInfo.MaxRetryAttempts;
}
public void Roundtrip2()
{
TimeSpan now = DateTime.UtcNow.TimeOfDay;
var conv = new TimeSpanConverter("G");
string?tmp = conv.ConvertToString(now);
Assert.IsNotNull(tmp);
var now2 = (TimeSpan?)conv.Parse(tmp);
Assert.AreEqual(now, now2);
}
public void ComponentModelCompatibilityTest()
{
var converter = new TimeSpanConverter();
var cmConverter = new System.ComponentModel.TimeSpanConverter();
var propertyMapData = new MemberMapData(null);
propertyMapData.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
var row = new CsvReader(new ParserMock());
Assert.Throws <FormatException>(() => cmConverter.ConvertFromString(""));
Assert.Throws <TypeConverterException>(() => converter.ConvertFromString("", row, propertyMapData));
Assert.Throws <NotSupportedException>(() => cmConverter.ConvertFromString(null));
Assert.Throws <TypeConverterException>(() => converter.ConvertFromString(null, row, propertyMapData));
}
public void WriteJson_GivenTimeOfDay_ShouldReturnFormattedString()
{
TimeSpanConverter converter = new TimeSpanConverter();
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter writer = new JsonTextWriter(sw))
{
JsonSerializer serializer = new JsonSerializer();
converter.WriteJson(writer, new TimeSpan(0, 10, 16, 54, 345), serializer);
Assert.AreEqual("\"10:16:54.3\"", sb.ToString());
}
}
public void WriteJson_GivenNullValue_ShouldReturnEmptyString()
{
TimeSpanConverter converter = new TimeSpanConverter();
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter writer = new JsonTextWriter(sw))
{
JsonSerializer serializer = new JsonSerializer();
converter.WriteJson(writer, null, serializer);
Assert.AreEqual("\"\"", sb.ToString());
}
}
public void GetTimeSpansFromDayPeriod_For_AUS_PM_Test()
{
const string input = "Australia/Sydney";
var timeZones = TimeSpanConverter.GetTimeSpansFromDayPeriod(DayPeriods.Pm, input);
var from = new DateTime(timeZones[0].From);
var to = new DateTime(timeZones[0].To);
timeZones.Count.Should().Be(1);
from.TimeOfDay.Should().BeLessThan(to.TimeOfDay);
// Midnight in AUS is 13:00:00
from.TimeOfDay.Should().Be(new DateTime(1, 1, 1, 01, 0, 0).TimeOfDay);
to.TimeOfDay.Should().Be(new DateTime(1, 1, 1, 12, 59, 59).TimeOfDay);
}
public void GetTimeSpansFromDayPeriod_For_US_AM_Test()
{
const string input = "America/New_York";
var timeZones = TimeSpanConverter.GetTimeSpansFromDayPeriod(DayPeriods.Am, input);
var from = new DateTime(timeZones[0].From);
var to = new DateTime(timeZones[0].To);
// Midnight in US is 05:00:00
// Noon in US is 17:00:00
timeZones.Count.Should().Be(1);
from.TimeOfDay.Should().BeLessThan(to.TimeOfDay);
from.TimeOfDay.Should().Be(new DateTime(1, 1, 1, 5, 0, 0).TimeOfDay);
to.TimeOfDay.Should().Be(new DateTime(1, 1, 1, 17, 0, 0).TimeOfDay);
}
public void GetTimeSpansFromDayPeriod_For_NZ_AM_Test()
{
const string input = "Pacific/Auckland";
var timeZones = TimeSpanConverter.GetTimeSpansFromDayPeriod(DayPeriods.Am, input);
var from = new DateTime(timeZones[0].From);
var to = new DateTime(timeZones[0].To);
timeZones.Count.Should().Be(1);
from.TimeOfDay.Should().BeLessThan(to.TimeOfDay);
// Noon in NZ is 23:00:00
from.TimeOfDay.Should().Be(new DateTime(1, 1, 1, 11, 0, 0).TimeOfDay);
to.TimeOfDay.Should().Be(new DateTime(1, 1, 1, 23, 0, 0).TimeOfDay);
}
public void Conversion()
{
// Arrange
IConverter converter = new TimeSpanConverter();
var value = "3:15:14";
var expectedValue = new TimeSpan(3, 15, 14);
// Act
var actualValue = converter.Convert(value, converter.TargetType);
// Assert
Assert.NotNull(actualValue);
Assert.IsType <TimeSpan>(actualValue);
Assert.Equal(expectedValue, (TimeSpan)actualValue);
}
public void ConvertFromStringWithHourSpecifier()
{
var tsc = new TimeSpanConverter();
var timeSpan = tsc.ConvertFrom("1H");
Assert.IsNotNull(timeSpan);
Assert.IsTrue(timeSpan is TimeSpan);
Assert.AreEqual(TimeSpan.FromHours(1), (TimeSpan)timeSpan);
tsc.ConvertFrom("1h");
Assert.IsNotNull(timeSpan);
Assert.IsTrue(timeSpan is TimeSpan);
Assert.AreEqual(TimeSpan.FromHours(1), (TimeSpan)timeSpan);
}
public void GetTimeSpansFromDayPeriod_For_Singapore_PM_Test()
{
const string input = "Asia/Singapore";
var timeZones = TimeSpanConverter.GetTimeSpansFromDayPeriod(DayPeriods.Pm, input);
var from = new DateTime(timeZones[0].From);
var to = new DateTime(timeZones[0].To);
timeZones.Count.Should().Be(1);
from.TimeOfDay.Should().BeLessThan(to.TimeOfDay);
//Midnight in Singapore is 04:00:00
// Noon in NZ is 16:00:00
from.TimeOfDay.Should().Be(new DateTime(1, 1, 1, 04, 0, 0).TimeOfDay);
to.TimeOfDay.Should().Be(new DateTime(1, 1, 1, 15, 59, 59).TimeOfDay);
}
public void ShouldConvertTimeSpanToShortDateString()
{
var time = new TimeSpan(15, 10, 30);
var converter = new TimeSpanConverter();
var result = converter.Convert(time, null, null, null);
Assert.AreEqual("15:10", result);
time = new TimeSpan(1, 3, 15);
result = converter.Convert(time, null, null, null);
Assert.AreEqual("01:03", result);
}
public Entry(Feedly.Entry entryDto) : base(entryDto.Id)
{
OriginId = entryDto.OriginId;
Fingerprint = entryDto.Fingerprint;
Updated = entryDto.Updated;
Title = entryDto.Title;
Published = entryDto.Published;
Crawled = entryDto.Crawled;
Author = entryDto.Author;
Summary = ExtractText(entryDto.Summary?.Content);
ThumbnailUrl = entryDto.Visual?.Url ?? string.Empty;
Content = entryDto.Content?.Content ?? string.Empty;
Unread = entryDto.Unread;
Engagement = entryDto.Engagement;
PublishedDate = TimeSpanConverter.ConvertToDate(Published).ToString("MMM dd");
ElepsedDays = (int)(DateTime.Now - TimeSpanConverter.ConvertToDate(Published)).TotalDays;
}
public void ConvertToExcelTest()
{
var converter = new TimeSpanConverter();
var typeConverterOptions = new TypeConverterOptions {
CultureInfo = CultureInfo.CurrentCulture
};
var dateTime = DateTime.Now;
var timeSpan = new TimeSpan(dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond);
// Valid conversions.
Assert.AreEqual(timeSpan.ToString(), converter.ConvertToExcel(typeConverterOptions, timeSpan));
// Invalid conversions.
Assert.AreEqual("1", converter.ConvertToExcel(typeConverterOptions, 1));
Assert.AreEqual(null, converter.ConvertToExcel(typeConverterOptions, null));
}
/// <summary>
/// Registers standard and configured type converters.
/// </summary>
static TypeConverterRegistry()
{
lock (converters.SyncRoot)
{
converters[typeof(string[])] = new StringArrayConverter();
converters[typeof(Type)] = new RuntimeTypeConverter();
converters[typeof(Color)] = new RGBColorConverter();
converters[typeof(Uri)] = new UriConverter();
converters[typeof(FileInfo)] = new FileInfoConverter();
converters[typeof(Stream)] = new StreamConverter();
converters[typeof(NameValueCollection)] = new NameValueConverter();
converters[typeof(ResourceManager)] = new ResourceManagerConverter();
converters[typeof(Regex)] = new RegexConverter();
converters[typeof(TimeSpan)] = new TimeSpanConverter();
converters[typeof(ICredentials)] = new CredentialConverter();
converters[typeof(NetworkCredential)] = new CredentialConverter();
converters[typeof(RegistryKey)] = new RegistryKeyConverter();
// register user-defined type converters
ConfigurationUtils.GetSection(TypeConvertersSectionName);
}
}
