public void TestProperties_DateTimeMinMinus1Day()
{
// 0000-12-31T00:00:00.000000000Z
var target = new Timestamp(-62135683200, 0);
Assert.That(target.UnixEpochSecondsPart, Is.EqualTo(-62135683200), "UnixEpochSecondsPart");
Assert.That(target.NanosecondsPart, Is.EqualTo(0), "NanosecondsPart");
Assert.That(target.Year, Is.EqualTo(0), "Year");
Assert.That(target.Month, Is.EqualTo(12), "Month");
Assert.That(target.Day, Is.EqualTo(31), "Day");
Assert.That(target.Hour, Is.EqualTo(0), "Hour");
Assert.That(target.Minute, Is.EqualTo(0), "Minute");
Assert.That(target.Second, Is.EqualTo(0), "Second");
Assert.That(target.Millisecond, Is.EqualTo(0), "Millisecond");
Assert.That(target.Microsecond, Is.EqualTo(0), "Microsecond");
Assert.That(target.Nanosecond, Is.EqualTo(0), "Nanosecond");
Assert.That(target.DayOfYear, Is.EqualTo(366), "DayOfYear");
Assert.That(target.DayOfWeek, Is.EqualTo(DayOfWeek.Sunday), "DayOfWeek");
Assert.That(target.IsLeapYear, Is.EqualTo(true), "IsLeapYear");
}
public void TestProperties_DateTimeMaxPlus1Sec()
{
// 10000-01-01T00:00:00.000000000Z
var target = new Timestamp(253402300800, 0);
Assert.That(target.UnixEpochSecondsPart, Is.EqualTo(253402300800), "UnixEpochSecondsPart");
Assert.That(target.NanosecondsPart, Is.EqualTo(0), "NanosecondsPart");
Assert.That(target.Year, Is.EqualTo(10000), "Year");
Assert.That(target.Month, Is.EqualTo(1), "Month");
Assert.That(target.Day, Is.EqualTo(1), "Day");
Assert.That(target.Hour, Is.EqualTo(0), "Hour");
Assert.That(target.Minute, Is.EqualTo(0), "Minute");
Assert.That(target.Second, Is.EqualTo(0), "Second");
Assert.That(target.Millisecond, Is.EqualTo(0), "Millisecond");
Assert.That(target.Microsecond, Is.EqualTo(0), "Microsecond");
Assert.That(target.Nanosecond, Is.EqualTo(0), "Nanosecond");
Assert.That(target.DayOfYear, Is.EqualTo(1), "DayOfYear");
Assert.That(target.DayOfWeek, Is.EqualTo(DayOfWeek.Saturday), "DayOfWeek");
Assert.That(target.IsLeapYear, Is.EqualTo(true), "IsLeapYear");
}
public void LoadMostRecentFromInstance()
{
var saveData = SaveDataTestImpl.NewSaveFile(nameof(LoadMostRecentFromInstance));
var firstEdit = "First Edit";
saveData.Word = firstEdit;
saveData.Save(false);
var saveData2 = SaveDataTestImpl.NewSaveFile(saveData.Nickname);
var secondEdit = "Second Edit";
saveData2.Word = secondEdit;
saveData2.Save(false);
Assert.That(saveData.Word, Is.EqualTo(firstEdit));
Assert.That(saveData, Is.Not.SameAs(saveData2));
var loadedSave = saveData.Reload();
Assert.That(loadedSave, Is.SameAs(saveData));
Assert.That(saveData.Word, Is.Not.EqualTo(firstEdit));
Assert.That(saveData.Word, Is.EqualTo(secondEdit));
}
public void TestProperties_Minus1Nsec()
{
// 1969-12-31T23:59:59.999999999Z
var target = new Timestamp(-1, 999999999);
Assert.That(target.UnixEpochSecondsPart, Is.EqualTo(-1), "UnixEpochSecondsPart");
Assert.That(target.NanosecondsPart, Is.EqualTo(999999999), "NanosecondsPart");
Assert.That(target.Year, Is.EqualTo(1969), "Year");
Assert.That(target.Month, Is.EqualTo(12), "Month");
Assert.That(target.Day, Is.EqualTo(31), "Day");
Assert.That(target.Hour, Is.EqualTo(23), "Hour");
Assert.That(target.Minute, Is.EqualTo(59), "Minute");
Assert.That(target.Second, Is.EqualTo(59), "Second");
Assert.That(target.Millisecond, Is.EqualTo(999), "Millisecond");
Assert.That(target.Microsecond, Is.EqualTo(999), "Microsecond");
Assert.That(target.Nanosecond, Is.EqualTo(999), "Nanosecond");
Assert.That(target.DayOfYear, Is.EqualTo(365), "DayOfYear");
Assert.That(target.DayOfWeek, Is.EqualTo(DayOfWeek.Wednesday), "DayOfWeek");
Assert.That(target.IsLeapYear, Is.EqualTo(false), "IsLeapYear");
}
public void PostThrowHandKarma()
{
FortuneFountainSaveData fortuneFountainSaveData = UglySaveData(nameof(PostThrowHandKarma));
AssertAll.Of(
() => Assert.That(fortuneFountainSaveData.Karma, Is.EqualTo(0)),
() => Assert.That(fortuneFountainSaveData.Hand.Throwables, Is.Not.Empty)
);
var expectedPostThrowKarma = fortuneFountainSaveData.Hand.KarmaInHand;
LogUtils.Log(
$"Before throwing, there is {fortuneFountainSaveData.Karma} karma",
$"In my hand, there is {fortuneFountainSaveData.Hand.KarmaInHand} karma"
);
fortuneFountainSaveData.Hand.Throw();
AssertAll.Of(
() => Assert.That(fortuneFountainSaveData.Karma, Is.EqualTo(expectedPostThrowKarma)),
() => Assert.That(fortuneFountainSaveData.Hand.Throwables, Is.Empty)
);
}
public void TestElelementMissingInTheFirstPlace_Map_MissingMembersAreSkipped()
{
using (var buffer = new MemoryStream())
{
var valueOfValue1 = "123";
using (var packer = Packer.Create(buffer, false))
{
packer.PackMapHeader(1);
packer.PackString("Value1");
packer.PackString(valueOfValue1);
}
buffer.Position = 0;
var context = this.CreateSerializationContext();
context.SerializationMethod = SerializationMethod.Map;
var target = CreateTarget <ComplexTypeWithTwoMember>(context);
var result = target.Unpack(buffer);
Assert.That(result.Value1, Is.EqualTo(valueOfValue1));
Assert.That(result.Value2, Is.EqualTo(new ComplexTypeWithTwoMember().Value2));
}
}
public void TestDispose_NotTail_Drained()
{
using (var buffer = new MemoryStream(new byte[] { 0x1, 0x92, 0x2, 0x3, 0x4 }))
using (var root = Unpacker.Create(buffer))
{
int lastValue;
Assert.That(root.ReadInt32(out lastValue));
Assert.That(lastValue, Is.EqualTo(1));
long length;
Assert.That(root.ReadArrayLength(out length));
Assert.That(length, Is.EqualTo(2));
using (var subtree = root.ReadSubtree())
{
Assert.That(subtree.ReadInt32(out lastValue));
Assert.That(lastValue, Is.EqualTo(2));
}
Assert.That(root.ReadInt32(out lastValue));
Assert.That(lastValue, Is.EqualTo(4));
}
}
public void TestEquality_ValueEqual()
{
foreach (var testCase in
new[]
{
Tuple.Create(0, 0, new byte[] { 1 }, new byte[] { 1 }, true),
Tuple.Create(0, 1, new byte[] { 1 }, new byte[] { 1 }, false),
Tuple.Create(0, 0, new byte[] { 1 }, new byte[] { 1, 2 }, false),
Tuple.Create(0, 0, new byte[] { 1 }, new byte[] { 2 }, false),
})
{
checked
{
MessagePackObject left = new MessagePackExtendedTypeObject(( byte )testCase.Item1, testCase.Item3);
MessagePackObject right = new MessagePackExtendedTypeObject(( byte )testCase.Item2, testCase.Item4);
Assert.That(left.Equals(right), Is.EqualTo(testCase.Item5), "IEquatable.Equals");
Assert.That(left.Equals(( object )right), Is.EqualTo(testCase.Item5), "Equals");
Assert.That(left == right, Is.EqualTo(testCase.Item5), "==");
Assert.That(left != right, Is.EqualTo(!testCase.Item5), "!=");
}
}
}
public void TestProperties_DateTimeMaxPlus1Nsec()
{
// 9999-12-31T23:59:59.000000001Z
var target = new Timestamp(253402300799, 1);
Assert.That(target.UnixEpochSecondsPart, Is.EqualTo(253402300799), "UnixEpochSecondsPart");
Assert.That(target.NanosecondsPart, Is.EqualTo(1), "NanosecondsPart");
Assert.That(target.Year, Is.EqualTo(9999), "Year");
Assert.That(target.Month, Is.EqualTo(12), "Month");
Assert.That(target.Day, Is.EqualTo(31), "Day");
Assert.That(target.Hour, Is.EqualTo(23), "Hour");
Assert.That(target.Minute, Is.EqualTo(59), "Minute");
Assert.That(target.Second, Is.EqualTo(59), "Second");
Assert.That(target.Millisecond, Is.EqualTo(0), "Millisecond");
Assert.That(target.Microsecond, Is.EqualTo(0), "Microsecond");
Assert.That(target.Nanosecond, Is.EqualTo(1), "Nanosecond");
Assert.That(target.DayOfYear, Is.EqualTo(365), "DayOfYear");
Assert.That(target.DayOfWeek, Is.EqualTo(DayOfWeek.Friday), "DayOfWeek");
Assert.That(target.IsLeapYear, Is.EqualTo(false), "IsLeapYear");
}
public void TypesAppearInTheCorrectOrder()
{
var names = new[] {
"SomeType",
"SomeType2",
"SomeNamespace.SomeType",
"SomeNamespace.InnerNamespace.OtherType1",
"SomeNamespace.InnerNamespace.OtherType2",
"SomeNamespace.SomeType.StrangeType1",
"SomeNamespace.SomeType.StrangeType2",
"SomeType2.SomeType3",
"SomeTYpe2.SomeType3.SomeType4",
};
var rnd = new Random(3);
var unorderedNames = names.Select(n => new { n = n, r = rnd.Next() }).OrderBy(x => x.r).Select(x => x.n).ToArray();
var output = Process(unorderedNames.Select(n => new JsClass(CreateMockType(n), n, JsClass.ClassTypeEnum.Class, null, null, null)));
var actual = output.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Where(l => l.StartsWith("// ")).Select(l => l.Substring(3)).ToList();
Assert.That(actual, Is.EqualTo(names));
}
public void TestProperties_Zero()
{
// 1970-01-01T00:00:00.000000000Z
var target = new Timestamp(0, 0);
Assert.That(target.UnixEpochSecondsPart, Is.EqualTo(0), "UnixEpochSecondsPart");
Assert.That(target.NanosecondsPart, Is.EqualTo(0), "NanosecondsPart");
Assert.That(target.Year, Is.EqualTo(1970), "Year");
Assert.That(target.Month, Is.EqualTo(1), "Month");
Assert.That(target.Day, Is.EqualTo(1), "Day");
Assert.That(target.Hour, Is.EqualTo(0), "Hour");
Assert.That(target.Minute, Is.EqualTo(0), "Minute");
Assert.That(target.Second, Is.EqualTo(0), "Second");
Assert.That(target.Millisecond, Is.EqualTo(0), "Millisecond");
Assert.That(target.Microsecond, Is.EqualTo(0), "Microsecond");
Assert.That(target.Nanosecond, Is.EqualTo(0), "Nanosecond");
Assert.That(target.DayOfYear, Is.EqualTo(1), "DayOfYear");
Assert.That(target.DayOfWeek, Is.EqualTo(DayOfWeek.Thursday), "DayOfWeek");
Assert.That(target.IsLeapYear, Is.EqualTo(false), "IsLeapYear");
}
public void TestProperties_DateTimeMinMinus1Nsec()
{
// 0000-12-31T23:59:59.999999999Z
var target = new Timestamp(-62135596801, 999999999);
Assert.That(target.UnixEpochSecondsPart, Is.EqualTo(-62135596801), "UnixEpochSecondsPart");
Assert.That(target.NanosecondsPart, Is.EqualTo(999999999), "NanosecondsPart");
Assert.That(target.Year, Is.EqualTo(0), "Year");
Assert.That(target.Month, Is.EqualTo(12), "Month");
Assert.That(target.Day, Is.EqualTo(31), "Day");
Assert.That(target.Hour, Is.EqualTo(23), "Hour");
Assert.That(target.Minute, Is.EqualTo(59), "Minute");
Assert.That(target.Second, Is.EqualTo(59), "Second");
Assert.That(target.Millisecond, Is.EqualTo(999), "Millisecond");
Assert.That(target.Microsecond, Is.EqualTo(999), "Microsecond");
Assert.That(target.Nanosecond, Is.EqualTo(999), "Nanosecond");
Assert.That(target.DayOfYear, Is.EqualTo(366), "DayOfYear");
Assert.That(target.DayOfWeek, Is.EqualTo(DayOfWeek.Sunday), "DayOfWeek");
Assert.That(target.IsLeapYear, Is.EqualTo(true), "IsLeapYear");
}
public void TestProperties_TimestampMin()
{
// -292277022657-01-27T08:29:52.000000000Z
var target = new Timestamp(-9223372036854775808, 0);
Assert.That(target.UnixEpochSecondsPart, Is.EqualTo(-9223372036854775808), "UnixEpochSecondsPart");
Assert.That(target.NanosecondsPart, Is.EqualTo(0), "NanosecondsPart");
Assert.That(target.Year, Is.EqualTo(-292277022657), "Year");
Assert.That(target.Month, Is.EqualTo(1), "Month");
Assert.That(target.Day, Is.EqualTo(27), "Day");
Assert.That(target.Hour, Is.EqualTo(8), "Hour");
Assert.That(target.Minute, Is.EqualTo(29), "Minute");
Assert.That(target.Second, Is.EqualTo(52), "Second");
Assert.That(target.Millisecond, Is.EqualTo(0), "Millisecond");
Assert.That(target.Microsecond, Is.EqualTo(0), "Microsecond");
Assert.That(target.Nanosecond, Is.EqualTo(0), "Nanosecond");
Assert.That(target.DayOfYear, Is.EqualTo(27), "DayOfYear");
Assert.That(target.DayOfWeek, Is.EqualTo(DayOfWeek.Saturday), "DayOfWeek");
Assert.That(target.IsLeapYear, Is.EqualTo(false), "IsLeapYear");
}
public void FindElementTwoBy()
{
Mock <IAllDriver> driver = new Mock <IAllDriver>();
Mock <IAllElement> elem1 = new Mock <IAllElement>();
Mock <IAllElement> elem2 = new Mock <IAllElement>();
Mock <IAllElement> elem3 = new Mock <IAllElement>();
Mock <IAllElement> elem4 = new Mock <IAllElement>();
Mock <IAllElement> elem5 = new Mock <IAllElement>();
var elems12 = new List <IWebElement>()
{
elem1.Object, elem2.Object
}.AsReadOnly();
var elems34 = new List <IWebElement>()
{
elem3.Object, elem4.Object
}.AsReadOnly();
var elems5 = new List <IWebElement>()
{
elem5.Object
}.AsReadOnly();
var elems345 = new List <IWebElement>()
{
elem3.Object, elem4.Object, elem5.Object
}.AsReadOnly();
driver.Setup(_ => _.FindElementsByName(It.Is <string>(x => x == "cheese"))).Returns(elems12);
elem1.Setup(_ => _.FindElements(It.Is <By>(x => x.Equals(By.Name("photo"))))).Returns(elems34);
elem2.Setup(_ => _.FindElements(It.Is <By>(x => x.Equals(By.Name("photo"))))).Returns(elems5);
ByChained by = new ByChained(By.Name("cheese"), By.Name("photo"));
Assert.That(by.FindElement(driver.Object), Is.EqualTo(elem3.Object));
driver.Verify(_ => _.FindElementsByName("cheese"), Times.Once);
elem1.Verify(_ => _.FindElements(By.Name("photo")), Times.Once);
elem2.Verify(_ => _.FindElements(By.Name("photo")), Times.Once);
}
public void TestUpdateExternal()
{
SvnSandBox sbox = new SvnSandBox(this);
Uri root = sbox.CreateRepository(SandBoxRepository.Empty);
Uri trunk = new Uri(root, "trunk/");
Uri alt = new Uri(root, "alt/");
Client.RemoteCreateDirectory(trunk);
Client.RemoteCreateDirectory(alt);
string dir = sbox.GetTempDir();
Client.CheckOut(trunk, dir);
Client.SetProperty(dir, SvnPropertyNames.SvnExternals,
string.Format("alt1 {0}\r\n" +
"alt2 {0}\n" +
"alt3 {0}", alt));
SvnUpdateArgs ua = new SvnUpdateArgs();
SortedList <string, string> paths = new SortedList <string, string>(StringComparer.OrdinalIgnoreCase);
ua.Notify += delegate(object sender, SvnNotifyEventArgs e)
{
if (e.Action != SvnNotifyAction.UpdateExternal)
{
return;
}
paths.Add(e.FullPath, e.FullPath);
};
Client.Update(dir, ua);
Assert.That(paths.Count, Is.EqualTo(3));
Assert.That(paths.ContainsKey(Path.Combine(dir, "alt2")));
}
public void FindElementsTwoByEmptyChild()
{
Mockery mocks = new Mockery();
IAllDriver driver = mocks.NewMock <IAllDriver>();
IAllElement elem1 = mocks.NewMock <IAllElement>();
IAllElement elem2 = mocks.NewMock <IAllElement>();
IAllElement elem3 = mocks.NewMock <IAllElement>();
IAllElement elem4 = mocks.NewMock <IAllElement>();
IAllElement elem5 = mocks.NewMock <IAllElement>();
var elems = new List <IWebElement>().AsReadOnly();
var elems12 = new List <IWebElement>()
{
elem1, elem2
}.AsReadOnly();
var elems34 = new List <IWebElement>()
{
elem3, elem4
}.AsReadOnly();
var elems5 = new List <IWebElement>()
{
elem5
}.AsReadOnly();
var elems345 = new List <IWebElement>()
{
elem3, elem4, elem5
}.AsReadOnly();
Expect.Once.On(driver).Method("FindElementsByName").With("cheese").Will(Return.Value(elems12));
Expect.Once.On(elem1).Method("FindElements").With(By.Name("photo")).Will(Return.Value(elems));
Expect.Once.On(elem2).Method("FindElements").With(By.Name("photo")).Will(Return.Value(elems5));
ByChained by = new ByChained(By.Name("cheese"), By.Name("photo"));
Assert.That(by.FindElements(driver), Is.EqualTo(new[] { elem5 }));
mocks.VerifyAllExpectationsHaveBeenMet();
}
private static void TestDataContractAndNonSerializableAreMixedCore(SerializationMethod method)
{
var context = new SerializationContext()
{
SerializationMethod = method
};
using (var buffer = new MemoryStream())
{
var target = new DataContractAndNonSerializedMixedTarget();
target.ShouldSerialized = 111;
var serializer = MessagePackSerializer.Create <DataContractAndNonSerializedMixedTarget>(context);
serializer.Pack(buffer, target);
buffer.Position = 0;
var intermediate = Unpacking.UnpackObject(buffer);
if (method == SerializationMethod.Array)
{
var asArray = intermediate.AsList();
Assert.That(asArray.Count, Is.EqualTo(1));
Assert.That(asArray[0] == target.ShouldSerialized);
}
else
{
var asMap = intermediate.AsDictionary();
Assert.That(asMap.Count, Is.EqualTo(1));
Assert.That(asMap["ShouldSerialized"] == target.ShouldSerialized);
}
buffer.Position = 0;
var result = serializer.Unpack(buffer);
Assert.That(result.ShouldSerialized, Is.EqualTo(target.ShouldSerialized));
}
}
public void Issue143()
{
var array =
new object[]
{
"111",
32432,
new int[] { 9, 8 },
909
};
var serializer = MessagePackSerializer.Get <object>(new SerializationContext());
var packedBinary = serializer.PackSingleObject(array);
var unpacked = serializer.UnpackSingleObject(packedBinary);
var unpackedList = (( MessagePackObject )unpacked).AsList();
Assert.That(unpackedList.Count, Is.EqualTo(4));
Assert.That(unpackedList[0] == "111");
Assert.That(unpackedList[1] == 32432);
Assert.That(unpackedList[2].IsList);
Assert.That(unpackedList[2].AsList().Count, Is.EqualTo(2));
Assert.That(unpackedList[2].AsList()[0] == 9);
Assert.That(unpackedList[2].AsList()[1] == 8);
Assert.That(unpackedList[3] == 909);
}
public void TestIssue99_HoGyuLee_AotForEnumKeyDictionary()
{
MessagePackSerializer.PrepareType <FileMode>();
using (var buffer = new MemoryStream(new byte[] { 0x81, 0x01, 0x00 }))
{
var serializer =
MessagePackSerializer.Get <Dictionary <FileMode, int> >(
PreGeneratedSerializerActivator.CreateContext(
SerializationMethod.Array,
PackerCompatibilityOptions.None
)
);
var result = serializer.Unpack(buffer);
Assert.That(result.Count, Is.EqualTo(1));
var singleResult = default(KeyValuePair <FileMode, int>);
foreach (var kv in result)
{
singleResult = kv;
}
Assert.That(singleResult.Key, Is.EqualTo(( FileMode )1));
Assert.That(singleResult.Value, Is.EqualTo(0));
}
}
private static void TestFieldInvalidTypeCore(SerializationMethod method, EmitterFlavor flavor)
{
var context = new SerializationContext()
{
SerializationMethod = method, EmitterFlavor = flavor
};
var serializer = MessagePackSerializer.Create <VersioningTestTarget>(context);
using (var stream = new MemoryStream())
{
if (method == SerializationMethod.Array)
{
stream.Write(new byte[] { 0x93, 0x1, 0xFF, 0x1 });
}
else
{
var packer = Packer.Create(stream, false);
packer.PackMapHeader(3);
packer.Pack("Field1");
packer.Pack(1);
packer.Pack("Field2");
packer.Pack(-1);
packer.Pack("Field3");
packer.Pack(1);
}
stream.Position = 0;
var result = serializer.Unpack(stream);
Assert.That(result.Field1, Is.EqualTo(1));
Assert.That(result.Field2, Is.EqualTo(-1));
Assert.That(result.Field3, Is.EqualTo("a"));
}
}
private static void TestFieldSwappedCore(EmitterFlavor flavor)
{
var serializer = CreateSerializer <VersioningTestTarget>(flavor);
using (var stream = new MemoryStream())
{
var packer = Packer.Create(stream, false);
packer.PackMapHeader(3);
packer.PackString("Field1");
packer.Pack(1);
packer.PackString("Field2");
packer.Pack(-1);
packer.PackString("Extra");
packer.Pack(2); // Issue6
stream.Position = 0;
var result = serializer.Unpack(stream);
Assert.That(result.Field1, Is.EqualTo(1));
Assert.That(result.Field2, Is.EqualTo(-1));
Assert.That(result.Field3, Is.Null);
}
}
public void TestReadExtendedTypeObject_FixExt1_AndBinaryLengthIs1_Extra()
{
var typeCode = ( byte )(Math.Abs(Environment.TickCount) % 128);
var data =
new byte[] { 0xD4, typeCode }
.Concat(Enumerable.Repeat(( byte )0xFF, 1)).ToArray();
using (var unpacker = this.CreateUnpacker(PrependAppendExtra(data), 1))
{
// Verify initial offset (prepended bytes length)
Assert.That(unpacker.Offset, Is.EqualTo(1));
MessagePackExtendedTypeObject result;
Assert.IsTrue(unpacker.ReadMessagePackExtendedTypeObject(out result));
Assert.That(result.TypeCode, Is.EqualTo(typeCode));
Assert.That(result.Body, Is.Not.Null);
Assert.That(result.Body.Length, Is.EqualTo(1));
// -1 is prepended extra bytes length
Assert.That(unpacker.Offset - 1, Is.EqualTo(data.Length));
}
}
public void TestToString_String_AsNullIFormatProvider()
{
var originalCurrentCulture = CultureInfo.CurrentCulture;
try
{
#if (!NET35 && !SILVERLIGHT) || WINDOWS_UWP
CultureInfo.CurrentCulture =
#else // ( !NET35 && !SILVERLIGHT ) || WINDOWS_UWP
Thread.CurrentThread.CurrentCulture =
#endif // ( !NET35 && !SILVERLIGHT ) || WINDOWS_UWP
new LegacyJapaneseCultureInfo();
if (!(CultureInfo.CurrentCulture is LegacyJapaneseCultureInfo) || CultureInfo.CurrentCulture.NumberFormat.NegativeSign != "\uFF0D")
{
Assert.Ignore("This platform does not support custom culture correctly.");
}
Assert.That(
new Timestamp(
-62193657600,
0
).ToString("s"),
Is.EqualTo("�|0001-03-01T00:00:00Z")
);
}
finally
{
#if (!NET35 && !SILVERLIGHT) || WINDOWS_UWP
CultureInfo.CurrentCulture =
#else // ( !NET35 && !SILVERLIGHT ) || WINDOWS_UWP
Thread.CurrentThread.CurrentCulture =
#endif // ( !NET35 && !SILVERLIGHT ) || WINDOWS_UWP
originalCurrentCulture;
}
}
public void TestToString_String_IFormatProvider_Distinguishable_s_null_CurrentCultureIsUsed()
{
var originalCurrentCulture = CultureInfo.CurrentCulture;
try
{
#if (!NET35 && !SILVERLIGHT) || WINDOWS_UWP
CultureInfo.CurrentCulture =
#else // ( !NET35 && !SILVERLIGHT ) || WINDOWS_UWP
Thread.CurrentThread.CurrentCulture =
#endif // ( !NET35 && !SILVERLIGHT ) || WINDOWS_UWP
new LegacyJapaneseCultureInfo();
if (!(CultureInfo.CurrentCulture is LegacyJapaneseCultureInfo) || CultureInfo.CurrentCulture.NumberFormat.NegativeSign != "\uFF0D")
{
Assert.Ignore("This platform does not support custom culture correctly.");
}
Assert.That(
new Timestamp(
-23215049511,
123456789
).ToString("s", null),
Is.EqualTo("1234-05-06T07:08:09Z")
);
}
finally
{
#if (!NET35 && !SILVERLIGHT) || WINDOWS_UWP
CultureInfo.CurrentCulture =
#else // ( !NET35 && !SILVERLIGHT ) || WINDOWS_UWP
Thread.CurrentThread.CurrentCulture =
#endif // ( !NET35 && !SILVERLIGHT ) || WINDOWS_UWP
originalCurrentCulture;
}
}
public void TestNestedArray()
{
using (var stream = new MemoryStream())
{
var packer = Packer.Create(stream);
packer.PackArray(
new[]
{
new MessagePackObject(new[] { new MessagePackObject("1-1"), new MessagePackObject("1-2"), new MessagePackObject("1-3") }),
new MessagePackObject(new[] { new MessagePackObject("2-1"), new MessagePackObject("2-2"), new MessagePackObject("2-3") }),
new MessagePackObject(new[] { new MessagePackObject("3-1"), new MessagePackObject("3-2"), new MessagePackObject("3-3") }),
}
);
stream.Position = 0;
var unpacker = Unpacker.Create(stream);
Assert.That(unpacker.Read());
using (Unpacker subtreeReader1 = unpacker.ReadSubtree())
{
Assert.That(subtreeReader1.IsArrayHeader);
Assert.That(subtreeReader1.ItemsCount, Is.EqualTo(3));
for (int i = 1; subtreeReader1.Read(); i++)
{
using (Unpacker subtreeReader2 = subtreeReader1.ReadSubtree())
{
Assert.That(subtreeReader2.IsArrayHeader);
Assert.That(subtreeReader2.ItemsCount, Is.EqualTo(3));
for (int j = 1; subtreeReader2.Read(); j++)
{
Assert.That(subtreeReader2.LastReadData.AsString(), Is.EqualTo(i + "-" + j));
}
}
}
}
}
}
public void Add_AddDirectoryNonRecursively()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.Empty);
string dir1, dir2, testFile1, testFile2;
CreateSubdirectories(sbox.Wc, out dir1, out dir2, out testFile1, out testFile2);
this.Client.Notify += new EventHandler <SvnNotifyEventArgs>(this.NotifyCallback);
SvnAddArgs a = new SvnAddArgs();
a.Depth = SvnDepth.Empty;
// do a non-recursive add here
this.Client.Add(dir1, a);
Assert.That(this.Notifications.Length == 1, "Too many or no notifications received. Added recursively?");
Assert.That(this.GetSvnStatus(dir1), Is.EqualTo(SvnStatus.Added), "Subdirectory not added");
Assert.That(GetSvnStatus(dir2), Is.Not.EqualTo(SvnStatus.Added), "Recursive add");
Assert.That(GetSvnStatus(testFile1), Is.Not.EqualTo(SvnStatus.Added), "Recursive add");
Assert.That(GetSvnStatus(testFile2), Is.Not.EqualTo(SvnStatus.Added), "Recursive add");
}
public void Path_ParsePaths()
{
SvnUriTarget ut;
SvnPathTarget pt;
SvnTarget st;
Assert.That(SvnUriTarget.TryParse("http://svn.apache.org/repos/asf/subversion/", out ut));
Assert.That(ut.Revision, Is.EqualTo(SvnRevision.None));
Assert.That(SvnUriTarget.TryParse("http://svn.apache.org/repos/asf/subversion/@123", out ut));
Assert.That(ut.Revision, Is.EqualTo(SvnRevision.None));
Assert.That(ut.TargetName.Contains("@"));
Assert.That(SvnUriTarget.TryParse("http://svn.apache.org/repos/asf/subversion/@123", true, out ut));
Assert.That(ut.Revision, Is.EqualTo((SvnRevision)123L));
Assert.That(SvnPathTarget.TryParse("C:\\A", out pt));
Assert.That(pt.Revision, Is.EqualTo(SvnRevision.None));
Assert.That(SvnPathTarget.TryParse("C:\\A@123", out pt));
Assert.That(pt.Revision, Is.EqualTo(SvnRevision.None));
Assert.That(pt.TargetName.Contains("@"));
Assert.That(SvnPathTarget.TryParse("C:\\@123", true, out pt));
Assert.That(pt.Revision, Is.EqualTo((SvnRevision)123L));
Assert.That(SvnTarget.TryParse("http://svn.apache.org/repos/asf/subversion/", out st));
Assert.That(st, Is.InstanceOf(typeof(SvnUriTarget)));
Assert.That(SvnTarget.TryParse("http://svn.apache.org/repos/asf/subversion/@123", out st));
Assert.That(st, Is.InstanceOf(typeof(SvnUriTarget)));
Assert.That(SvnTarget.TryParse("http://svn.apache.org/repos/asf/subversion/@123", true, out st));
Assert.That(st, Is.InstanceOf(typeof(SvnUriTarget)));
Assert.That(SvnTarget.TryParse("C:\\A", out st));
Assert.That(st, Is.InstanceOf(typeof(SvnPathTarget)));
Assert.That(SvnTarget.TryParse("C:\\A@123", out st));
Assert.That(st, Is.InstanceOf(typeof(SvnPathTarget)));
Assert.That(SvnTarget.TryParse("C:\\@123", true, out st));
Assert.That(st, Is.InstanceOf(typeof(SvnPathTarget)));
}
public void TestToUpperSnake(string input, string expected)
{
Assert.That(KeyNameTransformers.ToUpperSnake(input), Is.EqualTo(expected));
}
public void TestToLowerCamel(string input, string expected)
{
Assert.That(KeyNameTransformers.ToLowerCamel(input), Is.EqualTo(expected));
}
public void TestDirectivesOverwriteWithNoIgnoreDups()
{
IScheduler scheduler = null;
try
{
StdSchedulerFactory factory = new StdSchedulerFactory();
scheduler = factory.GetScheduler();
// Setup existing job with same names as in xml data.
string job1 = Guid.NewGuid().ToString();
IJobDetail job = JobBuilder.Create <NoOpJob>().WithIdentity(job1).Build();
ITrigger trigger = TriggerBuilder.Create().WithIdentity(job1).WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever()).Build();
scheduler.ScheduleJob(job, trigger);
string job2 = Guid.NewGuid().ToString();
job = JobBuilder.Create <NoOpJob>().WithIdentity(job2).Build();
trigger = TriggerBuilder.Create().WithIdentity(job2).WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever()).Build();
scheduler.ScheduleJob(job, trigger);
// Now load the xml data with directives: overwrite-existing-data=false, ignore-duplicates=true
XMLSchedulingDataProcessor processor = new XMLSchedulingDataProcessor(new SimpleTypeLoadHelper());
processor.ProcessStream(ReadJobXmlFromEmbeddedResource("directives_overwrite_no-ignoredups.xml"), "temp");
Assert.That(scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("DEFAULT")).Count, Is.EqualTo(2));
Assert.That(scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("DEFAULT")).Count, Is.EqualTo(2));
}
finally
{
if (scheduler != null)
{
scheduler.Shutdown();
}
}
}
