static public void Scratchpad()
{
var dt = DateTime.Now;
HdDateTime hdt = DateTime.UtcNow;
var ts = TimeSpan.FromSeconds(123);
var hts = HdTimeSpan.FromDays(123L);
//ts.Days
//dt.Day
//dt.AddDays()
//HdTimeSpan.
Console.WriteLine(HdDateTime.MinValue);
Console.WriteLine(HdDateTime.MaxValue);
Console.WriteLine(new HdDateTime(1678, 1, 1).EpochNanoseconds);
Console.WriteLine(new HdDateTime(2262, 1, 1).EpochNanoseconds);
Console.WriteLine(new HdDateTime(2262, 1, 1).AddNanoseconds(-1));
Console.WriteLine(HdDateTime.MaxValue);
Console.WriteLine(hdt);
Console.WriteLine(hdt.AddTicks(1));
Console.WriteLine(hdt.AddMilliseconds(1));
Console.WriteLine(hdt.AddSeconds(1));
Console.WriteLine(hdt.AddHours(12));
Console.WriteLine(hdt.AddDays(123));
int a = hdt.Millisecond, b = hdt.Second, c = hdt.Minute, d = hdt.Hour, e = hdt.Day, f = hdt.Month, g = hdt.Year, h = hdt.DayOfYear;
hdt = hdt.Date;
HdTimeSpan tsss = hdt.TimeOfDay;
DayOfWeek dw = hdt.DayOfWeek;
//dt.AddTicks();
//hdt.AddTicks()
}
public void TestEquals()
{
HdTimeSpan a1 = new HdTimeSpan(123);
HdTimeSpan a2 = new HdTimeSpan(123);
HdTimeSpan b = new HdTimeSpan(42);
Assert.True(a1 == a1);
Assert.False(a1 != a1);
Assert.True(a1 == a2);
Assert.False(a1 != a2);
Assert.True(a1.Equals(a2));
Assert.True(a2.Equals(a1));
Assert.True(a1.Equals((Object)a1));
Assert.True(a1.Equals((Object)a2));
Assert.True(a2.Equals((Object)a1));
Assert.True(((Object)a1).Equals((Object)a1));
Assert.True(((Object)a1).Equals((Object)a2));
Assert.True(((Object)a2).Equals((Object)a1));
Assert.True(((Object)a1).Equals((Object)a2));
Assert.True(((Object)a2).Equals((Object)a1));
Assert.False(a1 == b);
Assert.False(a2 == b);
Assert.True(a1 != b);
Assert.False(a1.Equals(b));
Assert.False(a2.Equals(b));
Assert.False(a1.Equals((Object)b));
Assert.False(((Object)a1).Equals(b));
Assert.False(((Object)a1).Equals((Object)b));
}
public void TestPrint()
{
TimeSpan ts = new TimeSpan(123, 45, 67, 9, 1234);
HdTimeSpan hts = new HdTimeSpan(ts);
Console.WriteLine(ts);
Console.WriteLine(hts);
Assert.Equals(ts.ToString(), hts.ToString());
}
public void TestPrint()
{
TimeSpan ts = new TimeSpan(123, 45, 67, 9, 1234);
HdTimeSpan hts = new HdTimeSpan(ts);
Console.Out.WriteLine(ts);
Console.Out.WriteLine(hts);
Assert.AreEqual(ts.ToString(), hts.ToString("d.HH:mm:ss.fffffff"));
}
public void TestSubtractDates(DateTime a, DateTime b)
{
TimeSpan timeSpan = a - b;
HdDateTime hdA = a;
HdDateTime hdB = b;
HdTimeSpan hdTimeSpan = hdA - hdB;
Assert.IsTrue(hdTimeSpan == timeSpan);
}
public void TestSubtract(TimeSpan a, TimeSpan b)
{
TimeSpan timeSpan = a - b;
HdTimeSpan hdA = a;
HdTimeSpan hdB = b;
HdTimeSpan hdTimeSpan = hdA - hdB;
Assert.IsTrue(hdTimeSpan == timeSpan);
}
public void CheckPrint(String str, String fmt, HdTimeSpan ts, bool compareWithTimeSpan = false)
{
Assert.AreEqual(str, ts.ToString(fmt));
if (compareWithTimeSpan)
{
Assert.AreEqual(ts.TimeSpan.ToString(fmt), ((HdTimeSpan)(ts.TimeSpan)).ToString(fmt));
}
//StringBuilder sb = new StringBuilder();
//Assert.AreEqual(str, num.appendTo(sb, fmt).toString());
}
public void TestAdd(TimeSpan a, TimeSpan b)
{
TimeSpan sum = a + b;
HdTimeSpan hdA = a;
HdTimeSpan hdB = b;
HdTimeSpan hdSum = hdA + hdB;
Assert.IsTrue(hdA == a);
Assert.IsTrue(hdB == b);
Assert.IsTrue(hdSum == sum);
}
private void CheckParse(String from, String fmt, HdTimeSpan expected)
{
HdTimeSpan parsed = HdTimeSpan.Parse(from, fmt);
if (!expected.Equals(parsed))
{
// Comparison is here to avoid problems with Formatter affecting tests for Parser
Assert.AreEqual(expected, parsed);
Assert.AreEqual(expected.ToString(), parsed.ToString());
}
Assert.AreEqual(expected.TotalNanoseconds, parsed.TotalNanoseconds);
}
private void CheckFormatFail(String from, String fmt, String msg)
{
try
{
HdTimeSpan.Parse(from, fmt);
}
catch (FormatError e)
{
if (e.Message.Contains(msg))
{
return;
}
}
Assert.Fail("Was expected to throw");
}
public void TestParse()
{
CheckParse("-0000091024123456", "ddddddddddHHmmss", new HdTimeSpan(-91024, -12, -34, -56));
CheckParse("5", "s", HdTimeSpan.FromSeconds(5));
CheckParse("0", "s", HdTimeSpan.FromSeconds(0));
CheckParse("005", "s", HdTimeSpan.FromSeconds(5));
CheckParse("12:34:56", "H:m:s", new HdTimeSpan(12, 34, 56));
CheckParse("12:34:56", "HH:mm:ss", new HdTimeSpan(12, 34, 56));
CheckParse("1024T12:34:56", "dTH:m:s", new HdTimeSpan(1024, 12, 34, 56));
CheckParse("1024T12:34:56", "d'T'H:m:s", new HdTimeSpan(1024, 12, 34, 56));
// Unseparated fixed width fields
CheckParse("123", "ss", HdTimeSpan.FromSeconds(12));
CheckParse("123456", "HHmmss", new HdTimeSpan(12, 34, 56));
CheckParse("1024123456", "ddddHHmmss", new HdTimeSpan(1024, 12, 34, 56));
CheckParse("91024123456", "dddddHHmmss", new HdTimeSpan(91024, 12, 34, 56));
CheckParse("0000091024123456", "ddddddddddHHmmss", new HdTimeSpan(91024, 12, 34, 56));
CheckParse("101024123456", "ddddddHHmmss", new HdTimeSpan(101024, 12, 34, 56));
// Sign
CheckParse("-5", "s", HdTimeSpan.FromSeconds(-5));
CheckParse("-1024T12:34:56", "dTH:m:s", new HdTimeSpan(-1024, -12, -34, -56));
CheckParse("-123456", "HHmmss", new HdTimeSpan(-12, -34, -56));
CheckParse("-0000091024123456", "ddddddddddHHmmss", new HdTimeSpan(-91024, -12, -34, -56));
// Fractions (Only fixed length patterns supported)
CheckParse("4.2", "s.f", HdTimeSpan.FromMilliseconds(4200));
CheckParse("4.200000", "s.ffffff", HdTimeSpan.FromMilliseconds(4200));
CheckParse("4.020", "s.ff", HdTimeSpan.FromMilliseconds(4020));
CheckParse("4.200000000", "s.fffffffff", HdTimeSpan.FromMilliseconds(4200));
CheckParse("4.000000002", "s.fffffffff", HdTimeSpan.FromNanoseconds(4000000002L));
CheckParse("4.2", "s.S", HdTimeSpan.FromMilliseconds(4200));
CheckParse("4.123", "s.SSS", HdTimeSpan.FromMilliseconds(4123));
}
public void TestAppend(MutableStringAppendTestType type)
{
if (type == MutableStringAppendTestType.Char)
{
s.Assign("sasd");
s.Append('e');
Assert.AreEqual(s, "sasde");
s.Assign('e');
Assert.AreEqual(s, "e");
s.Add('t');
Assert.AreEqual(s, "et");
}
if (type == MutableStringAppendTestType.String)
{
s.Assign("qwert");
s.Append("yuiop");
Assert.AreEqual(s, "qwertyuiop");
s.Assign("qwerty");
Assert.AreEqual(s, "qwerty");
}
if (type == MutableStringAppendTestType.Integer)
{
s.Assign("");
s.Append(-123);
Assert.AreEqual(s, "-123");
s.Assign("");
s.Append(124);
Assert.AreEqual(s, "124");
s.Assign(-123);
Assert.AreEqual(s, "-123");
s.Assign(124);
Assert.AreEqual(s, "124");
}
if (type == MutableStringAppendTestType.MutableString)
{
s.Assign("aba");
s1.Assign("caba");
s.Append(s1);
Assert.AreEqual(s, "abacaba");
s1.Append(s);
Assert.AreEqual(s1, "cabaabacaba");
s.Assign(s1);
Assert.AreEqual(s, "cabaabacaba");
}
if (type == MutableStringAppendTestType.ArrayOfChar)
{
s.Clear();
s.Append(ar);
Assert.AreEqual(s, "sswtuj1r");
s.Assign(ar);
Assert.AreEqual(s, "sswtuj1r");
}
if (type == MutableStringAppendTestType.ArrayOfCharWithOffset)
{
s.Clear();
s.Append(ar, 2, 4);
Assert.AreEqual(s, "wtuj");
s.Append(ar, 0, 1);
Assert.AreEqual(s, "wtujs");
s.Assign(ar, 2, 4);
Assert.AreEqual(s, "wtuj");
}
if (type == MutableStringAppendTestType.CharPtr)
{
unsafe
{
fixed(char *ptr = ar)
{
s.Clear();
s.Append(ptr, 5);
Assert.AreEqual(s, "sswtu");
s.Assign(ptr, 5);
Assert.AreEqual(s, "sswtu");
}
}
}
if (type == MutableStringAppendTestType.StringBuilder)
{
StringBuilder builder = new StringBuilder();
builder.Append("qazxcvb");
s.Clear();
s.Append(builder);
Assert.AreEqual(s, "qazxcvb");
s.Assign(builder);
Assert.AreEqual(s, "qazxcvb");
}
if (type == MutableStringAppendTestType.Long)
{
s.Assign("");
s.Append((long)-123);
Assert.AreEqual(s, "-123");
s.Assign("");
s.Append((long)124);
Assert.AreEqual(s, "124");
s.Assign((long)-123);
Assert.AreEqual(s, "-123");
s.Assign((long)124);
Assert.AreEqual(s, "124");
}
if (type == MutableStringAppendTestType.Short)
{
s.Assign("");
s.Append((short)-123);
Assert.AreEqual(s, "-123");
s.Assign("");
s.Append((short)124);
Assert.AreEqual(s, "124");
s.Assign((short)-123);
Assert.AreEqual(s, "-123");
s.Assign((short)124);
Assert.AreEqual(s, "124");
}
if (type == MutableStringAppendTestType.UTF8)
{
s.Clear();
s.AppendUTF8(utf8);
Assert.AreEqual(s, "AAAABa");
s.Clear();
s.AppendUTF8(utf8, 4, 2);
Assert.AreEqual(s, "Ba");
s.Clear();
unsafe
{
fixed(byte *ptr = utf8)
{
s.AppendUTF8(ptr, 6);
Assert.AreEqual(s, "AAAABa");
}
}
s.AssignUTF8(utf8);
Assert.AreEqual(s, "AAAABa");
s.AssignUTF8(utf8, 4, 2);
Assert.AreEqual(s, "Ba");
unsafe
{
fixed(byte *ptr = utf8)
{
s.AssignUTF8(ptr, 6);
Assert.AreEqual(s, "AAAABa");
}
}
}
if (type == MutableStringAppendTestType.UTF16)
{
String tempString = "abacaba";
utf16 = UnicodeEncoding.Unicode.GetBytes(tempString);
s.Clear();
s.AppendUTF16(utf16);
Assert.AreEqual(s, "abacaba");
s.Clear();
unsafe
{
fixed(byte *ptr = utf16)
{
s.AppendUTF16(ptr, 4);
Assert.AreEqual(s, "ab");
}
}
s.Clear();
s.AppendUTF16(utf16, 0, 4);
Assert.AreEqual(s, "ab");
s.AssignUTF16(utf16);
Assert.AreEqual(s, "abacaba");
unsafe
{
fixed(byte *ptr = utf16)
{
s.AssignUTF16(ptr, 4);
Assert.AreEqual(s, "ab");
}
}
s.AssignUTF16(utf16, 0, 4);
Assert.AreEqual(s, "ab");
}
if (type == MutableStringAppendTestType.UUID)
{
s.Clear();
s.Assign(uuid, UUIDPrintFormat.LowerCase);
s.Append(uuid, UUIDPrintFormat.LowerCase);
Assert.AreEqual("01234567-89ab-cdef-1011-12131415161701234567-89ab-cdef-1011-121314151617", s);
s.Clear();
s.Assign(uuid, UUIDPrintFormat.UpperCase);
s.Append(uuid, UUIDPrintFormat.UpperCase);
Assert.AreEqual("01234567-89AB-CDEF-1011-12131415161701234567-89AB-CDEF-1011-121314151617", s);
s.Clear();
s.Assign(uuid, UUIDPrintFormat.LowerCaseWithoutDashes);
s.Append(uuid, UUIDPrintFormat.LowerCaseWithoutDashes);
Assert.AreEqual("0123456789abcdef10111213141516170123456789abcdef1011121314151617", s);
s.Clear();
s.Assign(uuid, UUIDPrintFormat.UpperCaseWithoutDashes);
s.Append(uuid, UUIDPrintFormat.UpperCaseWithoutDashes);
Assert.AreEqual("0123456789ABCDEF10111213141516170123456789ABCDEF1011121314151617", s);
}
if (type == MutableStringAppendTestType.DateTime)
{
s.Clear();
DateTime dateTime = new DateTime(2016, 1, 1, 9, 7, 55, 555);
s.Append(dateTime);
Assert.AreEqual(s.ToString(), "01/01/2016 09:07:55.555");
dateTime = new DateTime(2016, 10, 11, 19, 17, 55, 555);
s.Assign(dateTime);
Assert.AreEqual(s.ToString(), "10/11/2016 19:17:55.555");
}
if (type == MutableStringAppendTestType.HdDateTime)
{
s.Clear();
HdDateTime dateTime = new HdDateTime(new DateTime(2016, 1, 1, 9, 7, 55, 555), 10);
s.Append(dateTime);
Assert.AreEqual(s.ToString(), "01/01/2016 09:07:55.555.10");
dateTime = new HdDateTime(new DateTime(2016, 10, 11, 19, 17, 55, 555), 9);
s.Assign(dateTime);
Assert.AreEqual(s.ToString(), "10/11/2016 19:17:55.555.09");
}
if (type == MutableStringAppendTestType.TimeSpan)
{
s.Clear();
TimeSpan timeSpan = new TimeSpan(10, 9, 7, 55, 555);
s.Append(timeSpan);
Assert.AreEqual(s.ToString(), "10.09:07:55.555");
timeSpan = new TimeSpan(9, 19, 17, 55, 55);
s.Assign(timeSpan);
Assert.AreEqual(s.ToString(), "9.19:17:55.055");
}
if (type == MutableStringAppendTestType.HdTimeSpan)
{
s.Clear();
HdTimeSpan timeSpan = new HdTimeSpan(new TimeSpan(10, 9, 7, 55, 555));
s.Append(timeSpan);
Assert.AreEqual(s.ToString(), "10.09:07:55.555.00");
timeSpan = new HdTimeSpan(new TimeSpan(9, 19, 17, 55, 55));
s.Assign(timeSpan);
Assert.AreEqual(s.ToString(), "9.19:17:55.055.00");
}
if (type == MutableStringAppendTestType.Double)
{
s.Clear();
s.Append((double)3.14);
Assert.AreEqual((s.ToString() == "3.14" || s.ToString() == "3,14"), true);
s.Assign((double)3.1459);
Assert.AreEqual((s.ToString() == "3.1459" || s.ToString() == "3,1459"), true);
}
if (type == MutableStringAppendTestType.Float)
{
s.Clear();
s.Append((float)3.14);
Assert.AreEqual((s.ToString() == "3.14" || s.ToString() == "3,14"), true);
s.Assign((float)3.1459);
Assert.AreEqual((s.ToString() == "3.1459" || s.ToString() == "3,1459"), true);
}
if (type == MutableStringAppendTestType.Boolean)
{
s.Clear();
s.Append(true);
Assert.AreEqual(s.ToString(), "True");
s.Assign(false);
Assert.AreEqual(s.ToString(), "False");
}
if (type == MutableStringAppendTestType.Decimal)
{
s.Clear();
s.Append((decimal)3.14);
Assert.AreEqual((s.ToString() == "3.14" || s.ToString() == "3,14"), true);
s.Assign((decimal)3.1459);
Assert.AreEqual((s.ToString() == "3.1459" || s.ToString() == "3,1459"), true);
}
if (type == MutableStringAppendTestType.Object)
{
s.Clear();
Tuple <int, int> tuple = new Tuple <int, int>(1, 1);
s.Append(tuple);
Assert.AreEqual(tuple.ToString(), s.ToString());
s.Assign(tuple);
Assert.AreEqual(tuple.ToString(), s.ToString());
}
}
public void TestFormat()
{
// Plain numbers
CheckPrint("34627623,.45634", "34627623,.45634", HdTimeSpan.FromSeconds(12), false);
// Check quoted text
CheckPrint("Abcmsy", "'Abcmsy'", HdTimeSpan.Zero);
CheckPrint("00Abcmsy000", "00'Abcmsy'000", HdTimeSpan.Zero, false);
CheckPrint("'Abc'msy", "'''Abc''msy'", HdTimeSpan.Zero, false);
CheckPrint("0'0Abc''msy00'0", "0''0'Abc''''msy'00''0", HdTimeSpan.Zero, false);
// Seconds
CheckPrint("12", "s", HdTimeSpan.FromSeconds(12));
CheckPrint("0", "s", HdTimeSpan.FromSeconds(0));
CheckPrint("00", "ss", HdTimeSpan.FromSeconds(0));
CheckPrint("005", "0ss", HdTimeSpan.FromSeconds(65));
CheckPrint("000005", "ssssss", HdTimeSpan.FromSeconds(65));
// Seconds & Fractions of Second. 'S' and 'f' are now synonyms
CheckPrint("12.3", "s.S", HdTimeSpan.FromMilliseconds(12_300));
CheckPrint("0.345", "s.SSS", HdTimeSpan.FromMicroseconds(345_000));
CheckPrint("00.023", "ss.SSS", HdTimeSpan.FromMilliseconds(600_023));
CheckPrint("05.123", "ss.SSS", HdTimeSpan.FromMilliseconds(65_123));
CheckPrint("05.123000", "ss.SSSSSS", HdTimeSpan.FromMilliseconds(65_123));
CheckPrint("05.0001", "ss.ffff", HdTimeSpan.FromMicroseconds(65_000_123));
CheckPrint("05.00012", "ss.fffff", HdTimeSpan.FromMicroseconds(65_000_123));
CheckPrint("05.000123", "ss.ffffff", HdTimeSpan.FromMicroseconds(65_000_123));
CheckPrint("05.123000", "ss.ffffff", HdTimeSpan.FromNanoseconds(65_123_000_123L));
CheckPrint("05.123000", "ss.ffffff", HdTimeSpan.FromNanoseconds(65_123_000_999L));
CheckPrint("05.123000", "ss.ffffff", HdTimeSpan.FromNanoseconds(65_123_000_999L));
CheckPrint("05.1230009", "ss.fffffff", HdTimeSpan.FromNanoseconds(65_123_000_999L));
CheckPrint("05.12300012", "ss.ffffffff", HdTimeSpan.FromNanoseconds(65_123_000_123L));
CheckPrint("05.123000123", "ss.fffffffff", HdTimeSpan.FromNanoseconds(65_123_000_123L));
CheckPrint("05.000000123", "ss.fffffffff", HdTimeSpan.FromNanoseconds(65_000_000_123L));
CheckPrint("5.000123000", "s.fffffffff", HdTimeSpan.FromNanoseconds(65_000_123_000L));
// Minutes
CheckPrint("5", "m", HdTimeSpan.FromMinutes(425));
CheckPrint("7", "m", HdTimeSpan.FromSeconds(425));
CheckPrint("05", "mm", HdTimeSpan.FromMinutes(425));
CheckPrint("00005", "0mmmm", HdTimeSpan.FromMinutes(425));
// Hours
CheckPrint("5", "H", HdTimeSpan.FromHours(48 + 5));
CheckPrint("4", "H", HdTimeSpan.FromMinutes(245));
CheckPrint("07", "HH", HdTimeSpan.FromMinutes(425));
CheckPrint("0007005", "0HHHmmm", HdTimeSpan.FromMinutes(425));
CheckPrint("07:5.789", "HH:m.SSS", HdTimeSpan.FromMinutes(425).Add(HdTimeSpan.FromMilliseconds(789)));
// Sign insertion
CheckPrint("-12", "s", HdTimeSpan.FromSeconds(-12));
CheckPrint("-0", "s", HdTimeSpan.FromMilliseconds(-1));
CheckPrint("-05", "ss", HdTimeSpan.FromSeconds(-425));
// "Advanced" sign insertion
CheckPrint("-000005", "ssssss", HdTimeSpan.FromSeconds(-425));
CheckPrint("-00000005", "00ssssss", HdTimeSpan.FromSeconds(-425));
CheckPrint("Abc-00000005", "Abc00ssssss", HdTimeSpan.FromSeconds(-425));
CheckPrint("Abcmsy-00000005", "'Abcmsy'00ssssss", HdTimeSpan.FromSeconds(-425));
CheckPrint(";.:-000005", ";.:ssssss", HdTimeSpan.FromSeconds(-425));
CheckPrint(";.:-00000005", ";.:00ssssss", HdTimeSpan.FromSeconds(-425));
}
