|
public Convert ( object value, Type, targetType, object parameter, |
||
| value | object | |
| targetType | Type, | |
| parameter | object | |
| culture | ||
| return | object | |
public bool Compare(object x, object y)
{
var converter = new DateTimeConverter();
var dtX = converter.Convert(x);
var dtY = converter.Convert(y);
return(Compare(dtX, dtY));
}
public void convert_returns_unset_value_if_value_is_not_a_date_time()
{
var converter = new DateTimeConverter();
Assert.Same(DependencyProperty.UnsetValue, converter.Convert(null, null, null, null));
Assert.Same(DependencyProperty.UnsetValue, converter.Convert("abc", null, null, null));
Assert.Same(DependencyProperty.UnsetValue, converter.Convert(123, null, null, null));
}
public override bool Apply(object x)
{
var converter = new DateTimeConverter();
var dtX = converter.Convert(x);
var dtY = converter.Convert(Reference);
return(Compare(dtX, dtY));
}
public void FromDateTime()
{
var converter = new DateTimeConverter();
var result = converter.Convert(new DateTime(2020, 5, 2, 13, 14, 41, 410));
Assert.AreEqual(new DateTime(2020, 5, 2, 13, 14, 41, 410), result);
}
public void InvDateTimeStringOnlyDateWithPeriodEnd()
{
var converter = new DateTimeConverter();
var result = converter.Convert("2020.5.2.");
Assert.AreEqual(new DateTime(2020, 5, 2), result);
}
public void InvDateTimeStringWithoutYear2()
{
var converter = new DateTimeConverter();
var result = converter.Convert("5.2");
Assert.AreEqual(new DateTime(DateTime.Now.Year, 5, 2), result);
}
public void InvDateTimeStringWithoutYear()
{
var converter = new DateTimeConverter();
var result = converter.Convert("5.2 13:14:41.410");
Assert.AreEqual(null, result);
}
/// <summary>
/// Реализует парсинг команды. При успешном парсинге аргументы помещаются в
/// </summary>
/// <param name="args">Аргументы команды.</param>
/// <returns>Возвращает признак того, что команда распознана.</returns>
public bool ParseArgs(string[] args)
{
// Проверяем, подходит ли команда по основным параметрам.
if (args.Length != _argumentTypes.Length + 1)
{
return(false);
}
if (!IsValid(args[0]))
{
return(false);
}
_commandArguments.Clear();
for (int i = 0; i < _argumentTypes.Length; i++)
{
switch (_argumentTypes[i].Name)
{
case "String":
{
_commandArguments.Add(args[i + 1]);
break;
}
case "Int32":
{
int outInt;
var parsed = Int32.TryParse(args[i + 1], out outInt);
if (parsed)
{
_commandArguments.Add(args[i + 1]);
}
break;
}
case "DateTime":
{
DateTime dt;
var parsed = DateTime.TryParseExact(args[i + 1], DateTimeConverter.DateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dt);
if (parsed)
{
_commandArguments.Add(DateTimeConverter.Convert(dt));
}
break;
}
default:
{
return(false);
}
}
}
return(_argumentTypes.Length == _commandArguments.Count);
}
public void InvDateTimeString()
{
var converter = new DateTimeConverter();
var result = converter.Convert("2020.05.02 13:14:41.410");
Assert.AreEqual(new DateTime(2020, 5, 2, 13, 14, 41, 410), result);
}
public void TestNanosecondPrecision()
{
// seeded DateTime
DateTime dt = DateTime.SpecifyKind(makeDateTime(2002, 12, 01, 11, 03, 05, 231, 116, 500), DateTimeKind.Utc);
// convert nanosecond DateTime to string with option
Assert.That(DateTimeConverter.Convert(dt, TimeStampPrecision.Nanosecond), Is.EqualTo("20021201-11:03:05.231116500"));
// convert nanosecond DateTime to time-only string
Assert.That(DateTimeConverter.ConvertTimeOnly(dt, TimeStampPrecision.Nanosecond), Is.EqualTo("11:03:05.231116500"));
// convert nanosecond time string to DateTime time portion only
DateTime timeOnly = makeTimeOnly(11, 03, 05, 231, 116, 500);
Assert.That(DateTimeConverter.ConvertToTimeOnly("11:03:05.231116500", TimeStampPrecision.Nanosecond), Is.EqualTo(timeOnly));
// convert nanosecond time string to full DateTime
Assert.That(DateTimeConverter.ConvertToDateTime("20021201-11:03:05.231116500", TimeStampPrecision.Nanosecond), Is.EqualTo(dt));
// convert nanosecond time with UTC time zone to full DateTime
Assert.That(DateTimeConverter.ConvertToDateTime("20021201-11:03:05.231116500Z", TimeStampPrecision.Nanosecond), Is.EqualTo(dt));
// convert nanosecond time with non-UTC positive offset time zone to full DateTime
Assert.That(DateTimeConverter.ConvertToDateTime("20021201-06:03:05.231116500+05", TimeStampPrecision.Nanosecond), Is.EqualTo(dt));
// convert nanosecond time with non-UTC negative offset time zone to full DateTime
Assert.That(DateTimeConverter.ConvertToDateTime("20021201-08:03:05.231116500-03", TimeStampPrecision.Nanosecond), Is.EqualTo(dt));
// convert nanosecond time in local time (no time zone) to full DateTime
DateTime local = DateTime.SpecifyKind(makeDateTime(2002, 12, 01, 11, 03, 05, 231, 116, 500), DateTimeKind.Local);
Assert.That(DateTimeConverter.ConvertToDateTime("20021201-11:03:05.231116500", TimeStampPrecision.Nanosecond), Is.EqualTo(local));
}
public void When_Convert_is_called_with_a_null_datetime_string_then_the_result_is_a_valid_DateTime_instance()
{
var converter = new DateTimeConverter();
var result = converter.Convert(null);
Assert.IsFalse(result.HasValue);
}
private static void DateTimePropertyChanged(BindableObject bindable, object oldValue, object newValue)
{
DetailedCell cell = (DetailedCell)bindable;
Device.BeginInvokeOnMainThread(() =>
{
if (newValue != null && !string.IsNullOrWhiteSpace(newValue.ToString()))
{
DateTimeConverter converter = new DateTimeConverter();
string date = newValue.ToString().Split(' ')[0];
string time = newValue.ToString().Split(' ')[1];
int day = int.Parse(date.Split('/')[0]);
int month = int.Parse(date.Split('/')[1]);
int year = int.Parse(date.Split('/')[2]);
int hour = int.Parse(time.Split(':')[0]);
int minute = int.Parse(time.Split(':')[1]);
int second = int.Parse(time.Split(':')[2]);
object fdt = converter.Convert(new DateTime(year, month, day, hour, minute, second), typeof(string), null, CultureInfo.CurrentCulture);
cell.DateTimeLabel.Text = fdt.ToString();
}
else
{
cell.DateTimeLabel.Text = "";
}
if (string.IsNullOrWhiteSpace(newValue.ToString()))
{
Grid.SetRowSpan(cell.TitleLabel, 2);
}
else
{
Grid.SetRowSpan(cell.TitleLabel, 1);
}
});
}
public bool Apply(object x)
{
var converter = new DateTimeConverter();
var dtX = converter.Convert(x);
return((dtX.TimeOfDay.Ticks) == 0);
}
public void ConvertToDateTimeTest(string time, int year, int momth, int day, int hour, int minute, int seconds, int millisec)
{
DateTime expected = new DateTime(year, momth, day, hour, minute, seconds, millisec).ToLocalTime();
DateTime actual = _dateTimeConverter.Convert(time);
Assert.AreEqual(expected, actual);
}
public void ShouldConvertNullDateTime()
{
var converter = new DateTimeConverter();
var result = converter.Convert(null, null, null, null);
Assert.IsNull(result);
}
public void DateTimeTest()
{
DateTimeConverter dtc = new DateTimeConverter();
DateTime actual = (DateTime)dtc.Convert("2019-10-19 13:01:21");
Assert.AreEqual(new DateTime(2019, 10, 19, 13, 1, 21), actual);
}
public void When_Convert_is_called_with_an_invalid_datetime_string_then_the_result_is_a_valid_DateTime_instance()
{
const string soundCloudDateTime = "20090813 18:30:10 +0000";
var converter = new DateTimeConverter();
var result = converter.Convert(soundCloudDateTime);
Assert.IsFalse(result.HasValue);
}
public void HandleNull()
{
var converter = new DateTimeConverter();
var result = converter.Convert(null);
Assert.Null(result);
}
public void Convert_Success()
{
//Act
var testValue = converter.Convert(testDate, typeof(string), null, null).ToString();
//Assert
Assert.Equal("Stycznia 01", testValue);
}
void AddLogs(IEnumerable<Pack> Packs) {
StringBuilder sb = new StringBuilder();
DateTimeConverter DateTimeConverter = new DateTimeConverter();
PackNameConverter PackNameConverter = new PackNameConverter();
string sep = ",";
foreach(Pack Pack in Packs) {
sb.Clear();
string date = DateTimeConverter.Convert(Pack.Time, null, null, null).ToString();
string packname = PackNameConverter.Convert(Pack.Id, null, null, null).ToString();
int commons = Pack.Cards.Count(x => x.Rarity == Rarity.COMMON);
int commonGolds = commons > 0 ? Pack.Cards.Count(x => x.Premium && x.Rarity == Rarity.COMMON) : 0;
int rares = Pack.Cards.Count(x => x.Rarity == Rarity.RARE);
int rareGolds = rares > 0 ? Pack.Cards.Count(x => x.Premium && x.Rarity == Rarity.RARE) : 0;
int epics = Pack.Cards.Count(x => x.Rarity == Rarity.EPIC);
int epicGolds = epics > 0 ? Pack.Cards.Count(x => x.Premium && x.Rarity == Rarity.EPIC) : 0;
int legendarys = Pack.Cards.Count(x => x.Rarity == Rarity.LEGENDARY);
int legendaryGolds = legendarys > 0 ? Pack.Cards.Count(x => x.Premium && x.Rarity == Rarity.LEGENDARY) : 0;
SolidColorBrush Color = null as SolidColorBrush;
if(legendarys > 0) {
Color = Legendary;
}
else if(epics > 0) {
Color = Epic;
}
else {
Color = Rare;
}
sb
.Append(date).Append(": ")
.Append(packname).Append("(")
.Append(commons);
AddGoldStars(commonGolds, Color, sb);
sb
.Append(sep)
.Append(rares);
AddGoldStars(rareGolds, Color, sb);
sb
.Append(sep)
.Append(epics);
AddGoldStars(epicGolds, Color, sb);
sb
.Append(sep)
.Append(legendarys);
AddGoldStars(legendaryGolds, Color, sb);
sb.AppendLine(")");
txt_Log.Inlines.Add(new Run(sb.ToString()) { Foreground = Color });
}
sv_Scrollbar.ScrollToEnd();
}
public async Task ProcessMessageAsync(object obj)
{
var book = obj as InOrderBook;
if (!book.IsValid())
{
_log.WriteWarning(nameof(MessageProcessor), nameof(Convert), $"Orderbook {book.ToJson()} is invalid!");
}
decimal bestPrice = 0;
if (book.Prices != null && book.Prices.Count > 0)
{
bestPrice = book.IsBuy
? (decimal)book.Prices.Max(p => p.Price)
: (decimal)book.Prices.Min(p => p.Price);
}
var orderbook = new OutOrderbook
{
AssetPairId = book.AssetPair,
IsBuy = book.IsBuy,
Timestamp = DateTimeConverter.Convert(book.Timestamp),
BestPrice = bestPrice,
};
if (!_minutesDict.ContainsKey(book.AssetPair))
{
_minutesDict.Add(book.AssetPair, new Dictionary <int, string>());
}
var assetPairDict = _minutesDict[book.AssetPair];
int minuteKey = GetMinuteKey(book.Timestamp);
var allCount = _minutesDict.Sum(i => i.Value.Values.Sum(k => k.Length));
if (allCount >= _maxBatchCount)
{
var allOtherMinutesItems = new List <string>();
foreach (var pair in _minutesDict)
{
foreach (var key in pair.Value.Keys.ToArray())
{
if (key == minuteKey)
{
continue;
}
allOtherMinutesItems.Add(pair.Value[key]);
pair.Value.Remove(key);
}
}
await _messagesHandler(StructureBuilder.MainContainer, allOtherMinutesItems);
}
assetPairDict[minuteKey] = orderbook.GetValuesString();
}
public void FromEpochDouble()
{
var converter = new DateTimeConverter()
{
EpochDate = new DateTime(1900, 1, 1)
};
var result = converter.Convert(12.5d);
Assert.AreEqual(new DateTime(1900, 1, 13, 12, 0, 0, 0), result);
}
public void ShouldConvertDateTimeToShortDateString()
{
var dateTime = new DateTime(2008, 12, 3);
var converter = new DateTimeConverter();
var result = converter.Convert(dateTime, null, null, null);
Assert.AreEqual(DateTime.Parse("2008-12-03").ToShortDateString(), result);
}
public void DateTimeFormatTest()
{
DateTimeConverter dtc = new DateTimeConverter();
dtc.Format = "HH?ss?mm MM=dd=yyyy";
DateTime actual = (DateTime)dtc.Convert("19?21?54 10=18=2018");
Assert.AreEqual(new DateTime(2018, 10, 18, 19, 54, 21), actual);
}
public void ShouldConvertDateTimeToShortDateString()
{
var dateTime = new DateTime(2008, 12, 3);
var converter = new DateTimeConverter();
var result = converter.Convert(dateTime, null, null, null);
Assert.AreEqual("12/3/2008", result);
}
public void HandleNullableDateTimesWithNoValue()
{
DateTime?input = null;
var converter = new DateTimeConverter();
var result = converter.Convert(input);
Assert.Null(result);
}
public void FromEpochInvString()
{
var converter = new DateTimeConverter()
{
EpochDate = new DateTime(1900, 1, 1)
};
var result = converter.Convert("1215.5");
Assert.AreEqual(new DateTime(1903, 5, 1, 12, 0, 0, 0), result);
}
public void HandleDateTimes()
{
DateTime input = new DateTime(2000, 1, 1);
var converter = new DateTimeConverter();
var result = converter.Convert(input);
Assert.Equal("01/01/2000 00:00:00", result);
}
public void Convert_DateTimeParsableObject()
{
var converter = new DateTimeConverter();
var converted = converter.Convert("2018-11-20",
typeof(string),
null,
CultureInfo.GetCultureInfo("en-US"));
Assert.Equal("Tuesday, November 20, 2018 (11/20/2018)", converted);
}
public void CanConvertFromDateTimeWithMicrosecondsToValidStringWithMicroSecondPrecision()
{
//GIVEN - a datetime object with microseconds
var dateTime = new DateTime(2017, 03, 05, 13, 22, 12, 123, DateTimeKind.Utc) + new TimeSpan(4560);
//WHEN - it is serialised to a string with microsecond precision
var serialisedDateTime = DateTimeConverter.Convert(dateTime, TimeStampPrecision.Microsecond);
//THEN - the serialised string contains microseconds
Assert.AreEqual("20170305-13:22:12.123456", serialisedDateTime);
}
public void Convert_ObjectDateTimeCanNotParse()
{
var converter = new DateTimeConverter();
var converted = converter.Convert(Guid.Empty,
typeof(string),
null,
CultureInfo.GetCultureInfo("en-US"));
Assert.Null(converted);
}
public void DateTimeConverterTest()
{
var dateString = "10/31/1990";
var cultureInfo = CultureInfo.InvariantCulture;
var date = DateTime.Parse(dateString, cultureInfo);
var converter = new DateTimeConverter();
var result = converter.Convert(date, null, null, cultureInfo);
Assert.AreEqual(result, date.ToString(
cultureInfo.DateTimeFormat.ShortDatePattern, cultureInfo));
}
public void ShouldConvert()
{
// Arrange
IValueConverter dateTimeConverter = new DateTimeConverter();
var input = new DateTime(2014, 8, 26, 18, 0, 0);
var expectedValue = (input).ToLocalTime().ToString(DefaultFormat, CultureInfo.CurrentUICulture);
// Act
var convertedOutput = dateTimeConverter.Convert(input, typeof(string), null, CultureInfo.CurrentUICulture);
// Assert
Assert.Equal(expectedValue, convertedOutput);
}
public void When_Convert_is_called_with_a_valid_datetime_string_then_the_result_is_a_valid_DateTime_instance()
{
const string soundCloudDateTime = "2009/08/13 18:30:10 +0000";
var converter = new DateTimeConverter();
var result = converter.Convert(soundCloudDateTime);
Assert.IsTrue(result.HasValue);
Assert.AreEqual(2009, result.Value.Year);
Assert.AreEqual(8, result.Value.Month);
Assert.AreEqual(13, result.Value.Day);
Assert.AreEqual(18, result.Value.Hour);
Assert.AreEqual(30, result.Value.Minute);
Assert.AreEqual(10, result.Value.Second);
}
