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(); } } }