public void GroupTokenIsNotNullWhenGroupsChangeToEmpty() { var response = new PersistentResponse(); var groupSet = new DiffSet <string>(new string[] { "b", "d" }); groupSet.DetectChanges(); groupSet.Remove("b"); groupSet.Remove("d"); var serializer = JsonUtility.CreateDefaultSerializer(); var protectedData = new Mock <IProtectedData>(); protectedData.Setup(m => m.Protect(It.IsAny <string>(), It.IsAny <string>())) .Returns <string, string>((value, purpose) => value); protectedData.Setup(m => m.Unprotect(It.IsAny <string>(), It.IsAny <string>())) .Returns <string, string>((value, purpose) => value); Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: "myconnection"); Assert.NotNull(response.GroupsToken); var parts = response.GroupsToken.Split(new[] { ':' }, 2); Assert.Equal(2, parts.Length); Assert.Equal("myconnection", parts[0]); var groups = serializer.Deserialize <string[]>(new JsonTextReader(new StringReader(parts[1]))); Assert.Equal(0, groups.Length); }
public void GroupTokenIsNotNullWhenGroupsChangeToEmpty() { var response = new PersistentResponse(); var groupSet = new DiffSet<string>(new string[] { "b", "d" }); groupSet.DetectChanges(); groupSet.Remove("b"); groupSet.Remove("d"); var serializer = new Mock<IJsonSerializer>(); HashSet<string> results = null; serializer.Setup(m => m.Serialize(It.IsAny<object>(), It.IsAny<TextWriter>())) .Callback<object, TextWriter>((obj, tw) => { results = new HashSet<string>((IEnumerable<string>)obj); var jsonNet = new JsonNetSerializer(); jsonNet.Serialize(obj, tw); }); var protectedData = new Mock<IProtectedData>(); protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); Connection.PopulateResponseState(response, groupSet, serializer.Object, protectedData.Object, connectionId: "myconnection"); Assert.NotNull(response.GroupsToken); var parts = response.GroupsToken.Split(new[] { ':' }, 2); Assert.Equal(2, parts.Length); Assert.Equal("myconnection", parts[0]); Assert.Equal(0, results.Count); }
public void MultipleTasksCanMakeChangesConcurrently() { var diffSet = new DiffSet <int>(Enumerable.Range(0, 100)); var diffPair = diffSet.GetDiff(); Assert.Equal(100, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); var tasks = new[] { Task.Factory.StartNew(() => { for (int i = 0; i < 50; i++) { Assert.True(diffSet.Remove(i)); } }), Task.Factory.StartNew(() => { for (int i = 100; i < 150; i++) { Assert.True(diffSet.Add(i)); } }) }; Task.WaitAll(tasks); Assert.Equal(100, diffSet.GetSnapshot().Count); for (int i = 50; i < 150; i++) { Assert.True(diffSet.Contains(i)); } diffPair = diffSet.GetDiff(); Assert.Equal(50, diffPair.Added.Count); Assert.Equal(50, diffPair.Removed.Count); Assert.False(diffPair.Reset); for (int i = 0; i < 50; i++) { Assert.False(diffSet.Contains(i)); Assert.False(diffPair.Added.Contains(i)); Assert.True(diffPair.Removed.Contains(i)); } for (int i = 50; i < 100; i++) { Assert.True(diffSet.Contains(i)); Assert.False(diffPair.Added.Contains(i)); Assert.False(diffPair.Removed.Contains(i)); } for (int i = 100; i < 50; i++) { Assert.True(diffSet.Contains(i)); Assert.True(diffPair.Added.Contains(i)); Assert.False(diffPair.Removed.Contains(i)); } }
public void UsingNullItemsFail() { Assert.Throws <ArgumentNullException>(() => new DiffSet <string>(new[] { "this", "should", "fail", null })); var diffSet = new DiffSet <string>(new[] { "this", "should", "succeed" }); Assert.Throws <ArgumentNullException>(() => diffSet.Add(null)); Assert.Throws <ArgumentNullException>(() => diffSet.Remove(null)); Assert.Throws <ArgumentNullException>(() => diffSet.Contains(null)); }
public void DetectChangesReturnsTrueIfChangedToNothing() { var diffSet = new DiffSet <int>(new[] { 1 }); diffSet.Remove(1); var result = diffSet.DetectChanges(); Assert.True(result); }
public void DetectChangesReturnsFalseNotChanged() { var diffSet = new DiffSet<int>(Enumerable.Empty<int>()); diffSet.Add(1); diffSet.Remove(1); var result = diffSet.DetectChanges(); Assert.False(result); }
public void AddingAndRemovingSameItemMultipleTimesShowsUpOnceInTheDiff() { var diffSet = new DiffSet <int>(Enumerable.Range(0, 100)); Assert.False(diffSet.Add(0)); // no-op Assert.True(diffSet.Remove(99)); Assert.False(diffSet.Remove(99)); // no-op Assert.Equal(99, diffSet.GetSnapshot().Count); var diffPair = diffSet.GetDiff(); Assert.Equal(99, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); for (int i = 0; i < 99; i++) { Assert.True(diffPair.Added.Contains(i)); Assert.True(diffSet.Contains(i)); } Assert.False(diffSet.Add(1)); // no-op Assert.True(diffSet.Add(99)); Assert.False(diffSet.Add(99)); // no-op Assert.False(diffSet.Remove(101)); // no-op Assert.True(diffSet.Remove(0)); Assert.False(diffSet.Remove(0)); // no-op Assert.Equal(99, diffSet.GetSnapshot().Count); diffPair = diffSet.GetDiff(); Assert.Equal(1, diffPair.Added.Count); Assert.Equal(1, diffPair.Removed.Count); Assert.False(diffPair.Reset); Assert.True(diffPair.Added.Contains(99)); Assert.True(diffPair.Removed.Contains(0)); for (int i = 1; i < 100; i++) { Assert.True(diffSet.Contains(i)); } }
public void DetectChangesReturnsFalseNotChanged() { var diffSet = new DiffSet <int>(Enumerable.Empty <int>()); diffSet.Add(1); diffSet.Remove(1); var result = diffSet.DetectChanges(); Assert.False(result); }
public void AddingAndRemovingSameItemMultipleTimesShowsUpOnceInTheDiff() { var diffSet = new DiffSet<int>(Enumerable.Range(0, 100)); Assert.False(diffSet.Add(0)); // no-op Assert.True(diffSet.Remove(99)); Assert.False(diffSet.Remove(99)); // no-op Assert.Equal(99, diffSet.GetSnapshot().Count); var diffPair = diffSet.GetDiff(); Assert.Equal(99, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); for (int i = 0; i < 99; i++) { Assert.True(diffPair.Added.Contains(i)); Assert.True(diffSet.Contains(i)); } Assert.False(diffSet.Add(1)); // no-op Assert.True(diffSet.Add(99)); Assert.False(diffSet.Add(99)); // no-op Assert.False(diffSet.Remove(101)); // no-op Assert.True(diffSet.Remove(0)); Assert.False(diffSet.Remove(0)); // no-op Assert.Equal(99, diffSet.GetSnapshot().Count); diffPair = diffSet.GetDiff(); Assert.Equal(1, diffPair.Added.Count); Assert.Equal(1, diffPair.Removed.Count); Assert.False(diffPair.Reset); Assert.True(diffPair.Added.Contains(99)); Assert.True(diffPair.Removed.Contains(0)); for (int i = 1; i < 100; i++) { Assert.True(diffSet.Contains(i)); } }
public void DetectChangesReturnsFalseNotChangedAgain() { var diffSet = new DiffSet<int>(new[] { 1 }); diffSet.Remove(1); diffSet.Add(1); var result = diffSet.DetectChanges(); var items = diffSet.GetSnapshot().ToList(); Assert.False(result); Assert.Equal(1, items[0]); Assert.Equal(1, items.Count); }
public void DetectChangesReturnsTrueIfNoneToSome() { var diffSet = new DiffSet<int>(Enumerable.Empty<int>()); diffSet.Add(1); diffSet.Remove(1); diffSet.Add(5); var result = diffSet.DetectChanges(); var items = diffSet.GetSnapshot().ToList(); Assert.True(result); Assert.Equal(5, items[0]); }
public void InitialValueCombineWithChangesInFirstDiff() { var diffSet = new DiffSet <int>(Enumerable.Range(0, 100)); Assert.True(diffSet.Add(-1)); Assert.True(diffSet.Add(100)); Assert.True(diffSet.Remove(0)); Assert.True(diffSet.Remove(-1)); Assert.Equal(100, diffSet.GetSnapshot().Count); var diffPair = diffSet.GetDiff(); Assert.Equal(100, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); for (int i = 1; i <= 100; i++) { Assert.True(diffPair.Added.Contains(i)); Assert.True(diffSet.Contains(i)); } }
public void InitialValueCombineWithChangesInFirstDiff() { var diffSet = new DiffSet <int>(Enumerable.Range(0, 100)); Assert.True(diffSet.Add(-1)); Assert.True(diffSet.Add(100)); Assert.True(diffSet.Remove(0)); Assert.True(diffSet.Remove(-1)); Assert.Equal(100, diffSet.GetSnapshot().Count); var changes = diffSet.DetectChanges(); var items = diffSet.GetSnapshot(); Assert.True(changes); Assert.Equal(100, items.Count); Assert.False(diffSet.Contains(0)); for (int i = 1; i <= 100; i++) { Assert.True(diffSet.Contains(i)); } }
public void DetectChangesReturnsFalseNotChangedAgain() { var diffSet = new DiffSet <int>(new[] { 1 }); diffSet.Remove(1); diffSet.Add(1); var result = diffSet.DetectChanges(); var items = diffSet.GetSnapshot().ToList(); Assert.False(result); Assert.Equal(1, items[0]); Assert.Equal(1, items.Count); }
public void DetectChangesReturnsTrueIfNoneToSome() { var diffSet = new DiffSet <int>(Enumerable.Empty <int>()); diffSet.Add(1); diffSet.Remove(1); diffSet.Add(5); var result = diffSet.DetectChanges(); var items = diffSet.GetSnapshot().ToList(); Assert.True(result); Assert.Equal(5, items[0]); }
public void GroupTokenIsNotNullWhenGroupsChangeToEmpty() { var response = new PersistentResponse(); var groupSet = new DiffSet <string>(new string[] { "b", "d" }); groupSet.DetectChanges(); groupSet.Remove("b"); groupSet.Remove("d"); var serializer = new Mock <IJsonSerializer>(); HashSet <string> results = null; serializer.Setup(m => m.Serialize(It.IsAny <object>(), It.IsAny <TextWriter>())) .Callback <object, TextWriter>((obj, tw) => { results = new HashSet <string>((IEnumerable <string>)obj); var jsonNet = new JsonNetSerializer(); jsonNet.Serialize(obj, tw); }); var protectedData = new Mock <IProtectedData>(); protectedData.Setup(m => m.Protect(It.IsAny <string>(), It.IsAny <string>())) .Returns <string, string>((value, purpose) => value); protectedData.Setup(m => m.Unprotect(It.IsAny <string>(), It.IsAny <string>())) .Returns <string, string>((value, purpose) => value); Connection.PopulateResponseState(response, groupSet, serializer.Object, protectedData.Object, connectionId: "myconnection"); Assert.NotNull(response.GroupsToken); var parts = response.GroupsToken.Split(new[] { ':' }, 2); Assert.Equal(2, parts.Length); Assert.Equal("myconnection", parts[0]); Assert.Equal(0, results.Count); }
public void DiffPairMatchesSnapshotAfterConcurrentChanges() { var random = new Random(); var diffSet = new DiffSet <int>(Enumerable.Range(0, 5)); var localSet = new HashSet <int>(Enumerable.Range(0, 5)); Action updateSet = () => { for (int i = 0; i < 100; i++) { if (random.Next(2) == 1) { diffSet.Remove(random.Next(5)); } else { diffSet.Add(random.Next(5)); } } }; // Flush initial changes var diffPair = diffSet.GetDiff(); Assert.Equal(5, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); for (int i = 0; i < 10; i++) { Task.WaitAll(Enumerable.Repeat(updateSet, 10).Select(Task.Factory.StartNew).ToArray()); var snapShot = diffSet.GetSnapshot(); diffPair = diffSet.GetDiff(); Assert.False(diffPair.Reset); Assert.Equal(0, diffPair.Added.Intersect(diffPair.Removed).Count()); foreach (var addedItem in diffPair.Added) { Assert.True(localSet.Add(addedItem)); } foreach (var removedItem in diffPair.Removed) { Assert.True(localSet.Remove(removedItem)); } int numSharedItems = localSet.Intersect(snapShot).Count(); Assert.Equal(numSharedItems, snapShot.Count); Assert.Equal(numSharedItems, localSet.Count); } }
public void DetectChangesReturnsTrueIfItemsNotAlreadyInSet() { var diffSet = new DiffSet<int>(new[] { 0, 10, 20 }); diffSet.Add(50); diffSet.Add(10); diffSet.Add(30); diffSet.Remove(10); var result = diffSet.DetectChanges(); var list = diffSet.GetSnapshot().OrderBy(i => i).ToList(); Assert.True(result); Assert.Equal(4, list.Count); Assert.Equal(0, list[0]); Assert.Equal(20, list[1]); Assert.Equal(30, list[2]); Assert.Equal(50, list[3]); }
public void DetectChangesReturnsTrueIfItemsNotAlreadyInSet() { var diffSet = new DiffSet <int>(new[] { 0, 10, 20 }); diffSet.Add(50); diffSet.Add(10); diffSet.Add(30); diffSet.Remove(10); var result = diffSet.DetectChanges(); var list = diffSet.GetSnapshot().OrderBy(i => i).ToList(); Assert.True(result); Assert.Equal(4, list.Count); Assert.Equal(0, list[0]); Assert.Equal(20, list[1]); Assert.Equal(30, list[2]); Assert.Equal(50, list[3]); }
public void AddingAndRemovingSameItemDoesNotShowUpInDiff() { var diffSet = new DiffSet <int>(Enumerable.Range(0, 100)); Assert.True(diffSet.Add(100)); Assert.True(diffSet.Remove(98)); Assert.True(diffSet.Remove(99)); Assert.True(diffSet.Remove(100)); Assert.True(diffSet.Add(99)); Assert.True(diffSet.Add(98)); Assert.Equal(100, diffSet.GetSnapshot().Count); var diffPair = diffSet.GetDiff(); Assert.Equal(100, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); for (int i = 0; i < 100; i++) { Assert.True(diffPair.Added.Contains(i)); Assert.True(diffSet.Contains(i)); } Assert.True(diffSet.Add(150)); Assert.True(diffSet.Add(200)); Assert.True(diffSet.Remove(50)); Assert.True(diffSet.Remove(200)); Assert.True(diffSet.Remove(150)); Assert.True(diffSet.Add(50)); Assert.Equal(100, diffSet.GetSnapshot().Count); diffPair = diffSet.GetDiff(); Assert.Equal(0, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.False(diffPair.Reset); for (int i = 0; i < 100; i++) { Assert.True(diffSet.Contains(i)); } }
public void AddingAndRemovingSameItemDoesNotShowUpInDiff() { var diffSet = new DiffSet<int>(Enumerable.Range(0, 100)); Assert.True(diffSet.Add(100)); Assert.True(diffSet.Remove(98)); Assert.True(diffSet.Remove(99)); Assert.True(diffSet.Remove(100)); Assert.True(diffSet.Add(99)); Assert.True(diffSet.Add(98)); Assert.Equal(100, diffSet.GetSnapshot().Count); var diffPair = diffSet.GetDiff(); Assert.Equal(100, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); for (int i = 0; i < 100; i++) { Assert.True(diffPair.Added.Contains(i)); Assert.True(diffSet.Contains(i)); } Assert.True(diffSet.Add(150)); Assert.True(diffSet.Add(200)); Assert.True(diffSet.Remove(50)); Assert.True(diffSet.Remove(200)); Assert.True(diffSet.Remove(150)); Assert.True(diffSet.Add(50)); Assert.Equal(100, diffSet.GetSnapshot().Count); diffPair = diffSet.GetDiff(); Assert.Equal(0, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.False(diffPair.Reset); for (int i = 0; i < 100; i++) { Assert.True(diffSet.Contains(i)); } }
public void AddingAndRemovingSameItemDoesNotShowUpInDiff() { // (0-100) var diffSet = new DiffSet <int>(Enumerable.Range(0, 100)); Assert.True(diffSet.Add(100)); Assert.True(diffSet.Remove(98)); Assert.True(diffSet.Remove(99)); Assert.True(diffSet.Remove(100)); Assert.True(diffSet.Add(99)); Assert.True(diffSet.Add(98)); Assert.Equal(100, diffSet.GetSnapshot().Count); // (0-100) var changes = diffSet.DetectChanges(); Assert.False(changes); for (int i = 0; i < 100; i++) { Assert.True(diffSet.Contains(i)); } Assert.True(diffSet.Add(150)); Assert.True(diffSet.Add(200)); Assert.True(diffSet.Remove(50)); Assert.True(diffSet.Remove(200)); Assert.True(diffSet.Remove(150)); Assert.True(diffSet.Add(50)); Assert.Equal(100, diffSet.GetSnapshot().Count); changes = diffSet.DetectChanges(); Assert.False(changes); for (int i = 0; i < 100; i++) { Assert.True(diffSet.Contains(i)); } }
public void DiffPairMatchesSnapshotAfterConcurrentChanges() { var random = new Random(); var diffSet = new DiffSet<int>(Enumerable.Range(0, 5)); var localSet = new HashSet<int>(Enumerable.Range(0, 5)); Action updateSet = () => { for (int i = 0; i < 100; i++) { if (random.Next(2) == 1) { diffSet.Remove(random.Next(5)); } else { diffSet.Add(random.Next(5)); } } }; // Flush initial changes var diffPair = diffSet.GetDiff(); Assert.Equal(5, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); for (int i = 0; i < 10; i++) { Task.WaitAll(Enumerable.Repeat(updateSet, 10).Select(Task.Factory.StartNew).ToArray()); var snapShot = diffSet.GetSnapshot(); diffPair = diffSet.GetDiff(); Assert.False(diffPair.Reset); Assert.Equal(0, diffPair.Added.Intersect(diffPair.Removed).Count()); foreach (var addedItem in diffPair.Added) { Assert.True(localSet.Add(addedItem)); } foreach (var removedItem in diffPair.Removed) { Assert.True(localSet.Remove(removedItem)); } int numSharedItems = localSet.Intersect(snapShot).Count(); Assert.Equal(numSharedItems, snapShot.Count); Assert.Equal(numSharedItems, localSet.Count); } }
public void InitialValueCombineWithChangesInFirstDiff() { var diffSet = new DiffSet<int>(Enumerable.Range(0, 100)); Assert.True(diffSet.Add(-1)); Assert.True(diffSet.Add(100)); Assert.True(diffSet.Remove(0)); Assert.True(diffSet.Remove(-1)); Assert.Equal(100, diffSet.GetSnapshot().Count); var diffPair = diffSet.GetDiff(); Assert.Equal(100, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); for (int i = 1; i <= 100; i++) { Assert.True(diffPair.Added.Contains(i)); Assert.True(diffSet.Contains(i)); } }
public void MultipleTasksCanMakeChangesConcurrently() { var diffSet = new DiffSet<int>(Enumerable.Range(0, 100)); var diffPair = diffSet.GetDiff(); Assert.Equal(100, diffPair.Added.Count); Assert.Equal(0, diffPair.Removed.Count); Assert.True(diffPair.Reset); var tasks = new[] { Task.Factory.StartNew(() => { for (int i = 0; i < 50; i++) { Assert.True(diffSet.Remove(i)); } }), Task.Factory.StartNew(() => { for (int i = 100; i < 150; i++) { Assert.True(diffSet.Add(i)); } }) }; Task.WaitAll(tasks); Assert.Equal(100, diffSet.GetSnapshot().Count); for (int i = 50; i < 150; i++) { Assert.True(diffSet.Contains(i)); } diffPair = diffSet.GetDiff(); Assert.Equal(50, diffPair.Added.Count); Assert.Equal(50, diffPair.Removed.Count); Assert.False(diffPair.Reset); for (int i = 0; i < 50; i++) { Assert.False(diffSet.Contains(i)); Assert.False(diffPair.Added.Contains(i)); Assert.True(diffPair.Removed.Contains(i)); } for (int i = 50; i < 100; i++) { Assert.True(diffSet.Contains(i)); Assert.False(diffPair.Added.Contains(i)); Assert.False(diffPair.Removed.Contains(i)); } for (int i = 100; i < 50; i++) { Assert.True(diffSet.Contains(i)); Assert.True(diffPair.Added.Contains(i)); Assert.False(diffPair.Removed.Contains(i)); } }
public void InitialValueCombineWithChangesInFirstDiff() { var diffSet = new DiffSet<int>(Enumerable.Range(0, 100)); Assert.True(diffSet.Add(-1)); Assert.True(diffSet.Add(100)); Assert.True(diffSet.Remove(0)); Assert.True(diffSet.Remove(-1)); Assert.Equal(100, diffSet.GetSnapshot().Count); var changes = diffSet.DetectChanges(); var items = diffSet.GetSnapshot(); Assert.True(changes); Assert.Equal(100, items.Count); Assert.False(diffSet.Contains(0)); for (int i = 1; i <= 100; i++) { Assert.True(diffSet.Contains(i)); } }
public void DetectChangesReturnsTrueIfChangedToNothing() { var diffSet = new DiffSet<int>(new[] { 1 }); diffSet.Remove(1); var result = diffSet.DetectChanges(); Assert.True(result); }
public void UsingNullItemsFail() { Assert.Throws<ArgumentNullException>(() => new DiffSet<string>(new[] {"this", "should", "fail", null})); var diffSet = new DiffSet<string>(new[] {"this", "should", "succeed"}); Assert.Throws<ArgumentNullException>(() => diffSet.Add(null)); Assert.Throws<ArgumentNullException>(() => diffSet.Remove(null)); Assert.Throws<ArgumentNullException>(() => diffSet.Contains(null)); }
public void GroupTokenIsNotNullWhenGroupsChangeToEmpty() { var response = new PersistentResponse(); var groupSet = new DiffSet<string>(new string[] { "b", "d" }); groupSet.DetectChanges(); groupSet.Remove("b"); groupSet.Remove("d"); var serializer = JsonUtility.CreateDefaultSerializer(); var protectedData = new Mock<IProtectedData>(); protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: "myconnection"); Assert.NotNull(response.GroupsToken); var parts = response.GroupsToken.Split(new[] { ':' }, 2); Assert.Equal(2, parts.Length); Assert.Equal("myconnection", parts[0]); var groups = serializer.Deserialize<string[]>(new JsonTextReader(new StringReader(parts[1]))); Assert.Equal(0, groups.Length); }
public void AddingAndRemovingSameItemDoesNotShowUpInDiff() { // (0-100) var diffSet = new DiffSet<int>(Enumerable.Range(0, 100)); Assert.True(diffSet.Add(100)); Assert.True(diffSet.Remove(98)); Assert.True(diffSet.Remove(99)); Assert.True(diffSet.Remove(100)); Assert.True(diffSet.Add(99)); Assert.True(diffSet.Add(98)); Assert.Equal(100, diffSet.GetSnapshot().Count); // (0-100) var changes = diffSet.DetectChanges(); Assert.False(changes); for (int i = 0; i < 100; i++) { Assert.True(diffSet.Contains(i)); } Assert.True(diffSet.Add(150)); Assert.True(diffSet.Add(200)); Assert.True(diffSet.Remove(50)); Assert.True(diffSet.Remove(200)); Assert.True(diffSet.Remove(150)); Assert.True(diffSet.Add(50)); Assert.Equal(100, diffSet.GetSnapshot().Count); changes = diffSet.DetectChanges(); Assert.False(changes); for (int i = 0; i < 100; i++) { Assert.True(diffSet.Contains(i)); } }