public void LazinatorListWithStructsWorks() { LazinatorList <WInt32> l = new LazinatorList <WInt32>() { 3 }; var c = l.CloneLazinatorTyped(); c[0].WrappedValue.Should().Be(3); c = l.CloneLazinatorTyped(); c.Insert(0, 2); var c2 = c.CloneLazinatorTyped(); c2[0].WrappedValue.Should().Be(2); c2[1].WrappedValue.Should().Be(3); c = l.CloneLazinatorTyped(); c.Add(4); var c3 = c.CloneLazinatorTyped(); c3[0].WrappedValue.Should().Be(3); c3[1].WrappedValue.Should().Be(4); c3.Add(5); c3[2].Should().Be(5); c = c2.CloneLazinatorTyped(); var accessed = c[1]; var c2b = c.CloneLazinatorTyped(); c2b[0].WrappedValue.Should().Be(2); c2b[1].WrappedValue.Should().Be(3); }
public void LazinatorListItemParentSet() { LazinatorList <ExampleChild> l = new LazinatorList <ExampleChild>() { new ExampleChild(), new ExampleChild() }; l[0].LazinatorParents.LastAdded.Should().Be(l); l[1].LazinatorParents.LastAdded.Should().Be(l); var c = l.CloneLazinatorTyped(); c[0].LazinatorParents.LastAdded.Should().Be(c); c[1].LazinatorParents.LastAdded.Should().Be(c); var c2 = l.CloneLazinatorTyped(); c2.Insert(0, new ExampleChild()); c2[1].LazinatorParents.LastAdded.Should().Be(c2); var c3 = l.CloneLazinatorTyped(); var lc3 = c3.ToList(); lc3[1].LazinatorParents.LastAdded.Should().Be(c3); var c4 = l.CloneLazinatorTyped(); var lc4 = c4.AsEnumerable().ToList(); lc4[1].LazinatorParents.LastAdded.Should().Be(c4); var c5 = l.CloneLazinatorTyped(); c5[0] = new ExampleChild(); c5[0].LazinatorParents.LastAdded.Should().Be(c5); }
public void CanCloneListOfLazinatorsAndThenEnsureUpToDate() { var l = new LazinatorList <Example>() { GetTypicalExample(), GetTypicalExample() }; var l2 = l.CloneLazinatorTyped(); var l3 = l.CloneLazinatorTyped(); l.SerializeLazinator(); }
public void CanCloneListOfStructsAndThenEnsureUpToDate() { // Note: This works because of IsStruct parameter in ReplaceBuffer. Without that parameter, the last call would lead to disposal of memory still needed. var l = new LazinatorList <WInt32>() { 1 }; var l2 = l.CloneLazinatorTyped(); var l3 = l.CloneLazinatorTyped(); l.SerializeLazinator(); }
public void LazinatorListWithEightByteContainer() { LazinatorList <EightByteLengthsContainer> l = new LazinatorList <EightByteLengthsContainer>() { new EightByteLengthsContainer() { Contents = new EightByteLengths() { Example = GetExample(0) } }, new EightByteLengthsContainer() { Contents = new EightByteLengths() { Example = GetExample(1) } }, null }; var l2 = l.CloneLazinatorTyped(); ExampleEqual(l[0].Contents.Example, l2[0].Contents.Example).Should().BeTrue(); ExampleEqual(l[1].Contents.Example, l2[1].Contents.Example).Should().BeTrue(); l2[2].Should().BeNull(); }
public void LazinatorListDirtinessWithNestedStructs() { LazinatorList <ExampleStructContainingStruct> l = new LazinatorList <ExampleStructContainingStruct>() { new ExampleStructContainingStruct() { MyExampleStructContainingClasses = new ExampleStructContainingClasses() { MyChar = 'Q' } } }; l.SerializeLazinator(); var c = l.CloneLazinatorTyped(); // consider original list, which should be clean l.IsDirty.Should().BeFalse(); l.DescendantIsDirty.Should().BeFalse(); l[0].IsDirty.Should().BeFalse(); l[0].MyExampleStructContainingClasses.IsDirty.Should().BeFalse(); // now consider clone c.IsDirty.Should().BeFalse(); c.DescendantIsDirty.Should().BeFalse(); c[0].IsDirty.Should().BeFalse(); c[0].MyExampleStructContainingClasses.IsDirty.Should().BeFalse(); c[0].MyExampleStructContainingClasses.MyChar.Should().Be('Q'); }
public void EmptyLazinatorListWorks() { LazinatorList <WInt32> l = new LazinatorList <WInt32>(); var c = l.CloneLazinatorTyped(); c.Count().Should().Be(0); }
public void ShortLazinatorListWorks() { LazinatorList <WInt32> l = new LazinatorList <WInt32>(); l.Add(3); var c = l.CloneLazinatorTyped(); var result = c[0]; result.Should().Be(3); }
public void LazinatorListEnumerateNodesWorks() { LazinatorList <Example> l = new LazinatorList <Example>() { GetExample(1), GetExample(1) }; var c = l.CloneLazinatorTyped(); var results2 = c.EnumerateAllNodes().ToList(); results2[0].Should().Be(c); results2[1].LazinatorParents.LastAdded.Should().Be(c); }
public void LazinatorListEnumeratorWorks() { LazinatorList <Example> l = new LazinatorList <Example>() { GetExample(1), GetExample(1) }; var results = l.ToList(); results[0].LazinatorParents.LastAdded.Should().Be(l); results[1].LazinatorParents.LastAdded.Should().Be(l); var c = l.CloneLazinatorTyped(); results = c.ToList(); results[0].LazinatorParents.LastAdded.Should().Be(c); results[1].LazinatorParents.LastAdded.Should().Be(c); c = l.CloneLazinatorTyped(); foreach (var result in c) { result.LazinatorParents.LastAdded.Should().Be(c); } }
void BinaryHashInList() { var wrapped = new WInt32(1); var wrapped2 = new WInt32(1); LazinatorList <WInt32> x = new LazinatorList <WInt32>(); x.Add(wrapped2); x.GetListMemberHash32(0).Should().Be(wrapped.GetBinaryHashCode32()); var clone = x.CloneLazinatorTyped(); clone.GetListMemberHash32(0).Should().Be(wrapped.GetBinaryHashCode32()); }
public void LazinatorListWorksWithPartialAccessAfterChange() { LazinatorList <WInt32> l = new LazinatorList <WInt32>(); l.Add(3); l.Add(4); var c = l.CloneLazinatorTyped(); c[0] = 999999; var c2 = c.CloneLazinatorTyped(); c2[1].WrappedValue.Should().Be(4); }
public void ChangeToObjectAppearingTwiceInLazinatorListAffectsBoth() { LazinatorList <ExampleChild> e = new LazinatorList <ExampleChild>() { new ExampleChild(), new ExampleChild() { MyLong = -123456 } }; var c = e.CloneLazinatorTyped(); c[0] = c[1]; c[0].MyLong = -987; var c2 = c.CloneLazinatorTyped(); c2[0].MyLong.Should().Be(-987); c2[1].MyLong.Should().Be(-987); }
public void LazinatorListDirtinessWithStructs() { LazinatorList <WInt32> l = new LazinatorList <WInt32>() { new WInt32(3) }; l.SerializeLazinator(); var c = l.CloneLazinatorTyped(); // consider original list, which should be clean l.IsDirty.Should().BeFalse(); l.DescendantIsDirty.Should().BeFalse(); l[0].IsDirty.Should().BeFalse(); // now consider clone c.IsDirty.Should().BeFalse(); c.DescendantIsDirty.Should().BeFalse(); c[0].IsDirty.Should().BeFalse(); }
public void LazinatorListCountWorks() { LazinatorList <Example> l = new LazinatorList <Example>() { GetExample(1), GetExample(1) }; l.Count.Should().Be(2); l.Add(null); l.Count.Should().Be(3); l.RemoveAt(1); l.Count.Should().Be(2); var c = l.CloneLazinatorTyped(); c.Count.Should().Be(2); c.Insert(0, GetExample(1)); c.Count.Should().Be(3); c.Add(GetExample(2)); c.Count.Should().Be(4); c.RemoveAll(x => true); c.Count.Should().Be(0); }
public void LazinatorListForEachLazinatorWorks() { LazinatorList <WString> l = new LazinatorList <WString>() { "hello", "world" }; StringBuilder sb = new StringBuilder(); var c = l.ForEachLazinator(x => { if (x is WString ws) { sb.Append(ws.WrappedValue); } return(x); }, true, true); sb.ToString().Should().Be("helloworld"); l = l.CloneLazinatorTyped(); sb = new StringBuilder(); c = l.ForEachLazinator(x => { if (x is WString ws) { sb.Append(ws.WrappedValue); } return(x); }, true, true); sb.ToString().Should().Be(""); c = l.ForEachLazinator(x => { if (x is WString ws) { sb.Append(ws.WrappedValue); } return(x); }, false, true); // now deserialize sb.ToString().Should().Be("helloworld"); }
public void SimplifiableWorks() { Simplifiable s = new Simplifiable() { ANonSkippableEarlierExample = new Example() { MyChar = 'A' } }; var c = s.CloneLazinatorTyped(); s.MyInt.Should().Be(0); s.MyOtherInt.Should().Be(0); s.Example.Should().BeNull(); s.Example2.Should().BeNull(); s.Example3.Should().BeNull(); var originalbytes = s.SerializeLazinator(new LazinatorSerializationOptions(IncludeChildrenMode.IncludeAllChildren, false, false, false)); // take advantage of simplifications s = new Simplifiable() { MyInt = 3, MyOtherInt = 3, ANonSkippableEarlierExample = new Example() { MyChar = 'A' }, Example = new Example() { MyChar = 'X', MyString = Simplifiable.LongString }, Example2 = new Example() { MyChar = 'Z' }, Example3 = null }; c = s.CloneLazinatorTyped(); s.MyInt.Should().Be(3); s.MyOtherInt.Should().Be(3); s.ANonSkippableEarlierExample.MyChar.Should().Be('A'); s.Example.MyChar.Should().Be('X'); s.Example.MyString.Should().Be(Simplifiable.LongString); s.Example2.MyChar.Should().Be('Z'); s.Example3.Should().BeNull(); var d = s.SerializeLazinator(new LazinatorSerializationOptions(IncludeChildrenMode.IncludeAllChildren, false, false, false)); d.InitialReadOnlyMemory.Length.Should().BeLessOrEqualTo(originalbytes.InitialReadOnlyMemory.Length); // shorter even though it is more complex once constructed // now use the values that are not simplified s = new Simplifiable() { MyInt = 4, MyOtherInt = 5, Example = new Example() { MyChar = 'A', MyString = "Hello" }, Example2 = null, Example3 = new Example() { MyDateTime = new System.DateTime(123456) } }; c = s.CloneLazinatorTyped(); s.MyInt.Should().Be(4); s.MyOtherInt.Should().Be(5); s.Example.MyChar.Should().Be('A'); s.Example.MyString.Should().Be("Hello"); s.Example2.Should().BeNull(); s.Example3.MyDateTime.Ticks.Should().Be(123456); var l = new LazinatorList <Simplifiable>() { new Simplifiable() { MyInt = 3, MyOtherInt = 3 } }; var cl = l.CloneLazinatorTyped(); cl[0].MyIntsAre3.Should().BeTrue(); cl[0].MyInt.Should().Be(3); cl[0].MyOtherInt.Should().Be(3); cl[0].MyInt = 2; cl = cl.CloneLazinatorTyped(); cl[0].MyIntsAre3.Should().BeFalse(); cl[0].MyInt = 3; cl = cl.CloneLazinatorTyped(); cl[0].MyIntsAre3.Should().BeTrue(); cl[0].MyInt = 2; cl.SerializeLazinator(); cl[0].MyIntsAre3.Should().BeFalse(); }