public Connection(IMessageBus newMessageBus,
JsonSerializer jsonSerializer,
string baseSignal,
string connectionId,
IList<string> signals,
IList<string> groups,
ILoggerFactory loggerFactory,
IAckHandler ackHandler,
IPerformanceCounterManager performanceCounterManager,
IProtectedData protectedData,
IMemoryPool pool)
{
if (loggerFactory == null)
{
throw new ArgumentNullException("loggerFactory");
}
_bus = newMessageBus;
_serializer = jsonSerializer;
_baseSignal = baseSignal;
_connectionId = connectionId;
_signals = new List<string>(signals.Concat(groups));
_groups = new DiffSet<string>(groups);
_logger = loggerFactory.CreateLogger<Connection>();
_ackHandler = ackHandler;
_counters = performanceCounterManager;
_protectedData = protectedData;
_excludeMessage = m => ExcludeMessage(m);
_pool = pool;
}
public Connection(IMessageBus newMessageBus,
IJsonSerializer jsonSerializer,
string baseSignal,
string connectionId,
IList<string> signals,
IList<string> groups,
ITraceManager traceManager,
IAckHandler ackHandler,
IPerformanceCounterManager performanceCounterManager,
IProtectedData protectedData)
{
if (traceManager == null)
{
throw new ArgumentNullException("traceManager");
}
_bus = newMessageBus;
_serializer = jsonSerializer;
_baseSignal = baseSignal;
_connectionId = connectionId;
_signals = new List<string>(signals.Concat(groups));
_groups = new DiffSet<string>(groups);
_traceSource = traceManager["SignalR.Connection"];
_ackHandler = ackHandler;
_counters = performanceCounterManager;
_protectedData = protectedData;
}
public void GroupTokenIsNotNullWhenGroupsChange()
{
var response = new PersistentResponse();
var groupSet = new DiffSet<string>(new string[] { "a", "b", "c", "d" });
groupSet.GetDiff();
groupSet.Add("g");
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);
Assert.NotNull(response.GroupsToken);
Assert.True(results.Contains("a"));
Assert.True(results.Contains("b"));
Assert.True(results.Contains("c"));
Assert.True(results.Contains("d"));
Assert.True(results.Contains("g"));
}
public void GroupTokenIsNotNullWhenGroupsChange()
{
var response = new PersistentResponse();
var groupSet = new DiffSet<string>(new string[] { "a:1", "b:2", "c", "d" });
groupSet.DetectChanges();
groupSet.Add("g");
var serializer = JsonUtility.CreateDefaultSerializer();
string results = string.Empty;
var protectedData = new Mock<IProtectedData>();
protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((value, purpose) =>
{
results = value;
return 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]);
Assert.True(results.Contains("a:1"));
Assert.True(results.Contains("b:2"));
Assert.True(results.Contains("c"));
Assert.True(results.Contains("d"));
Assert.True(results.Contains("g"));
}
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 Diff_equal_collections()
{
var actual = MakeStubCollection("name1", "value1", "name2", "value2", "name3", "value3");
var expected = MakeStubCollection("name1", "value1", "name2", "value2", "name3", "value3");
DiffSet diffSet = actual.Diff(expected, XmlPathRoot.Strict.Element(0), XmlPathRoot.Strict.Element(0), XmlOptions.Strict.Value);
Assert.IsEmpty(diffSet);
}
public void ContainsDocumentAndDiffs()
{
DiffSet diffSet = new DiffSet(new[] { new Diff(DiffKind.Change, new Range(0, 3), new Range(0, 3)) }, "abc", "def");
Assert.AreEqual("abc", diffSet.LeftDocument);
Assert.AreEqual("def", diffSet.RightDocument);
Assert.AreElementsEqual(new[] { new Diff(DiffKind.Change, new Range(0, 3), new Range(0, 3)) }, diffSet.Diffs);
}
public void NoChangeSpansBothDocuments()
{
DiffSet diffSet = DiffSet.GetDiffSet("this is a test", "this is a test");
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsFalse(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] { new Diff(DiffKind.NoChange, new Range(0, 14), new Range(0, 14)) }, diffSet.Diffs);
}
public void ComputedDiffIsEmpty()
{
DiffSet diffSet = DiffSet.GetDiffSet("", "");
Assert.IsTrue(diffSet.IsEmpty);
Assert.IsFalse(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] { }, diffSet.Diffs);
}
public void IfRightDocumentIsEmptyChangeSpansLeftDocument()
{
DiffSet diffSet = DiffSet.GetDiffSet("abcde", "");
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] { new Diff(DiffKind.Change, new Range(0, 5), new Range(0, 0)) },
diffSet.Diffs);
}
public void SingleCharDelete([Column(false, true)] bool optimize)
{
DiffSet diffSet = DiffSet.GetDiffSet("1", "", optimize, true);
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] {
new Diff(DiffKind.Change, new Range(0, 1), new Range(0, 0))
}, diffSet.Diffs);
}
public void Constructs_ok()
{
var mockPath = MockRepository.GenerateStub<IXmlPathStrict>();
var diff1 = new Diff(DiffType.MissingAttribute, mockPath, DiffTargets.Actual);
var diff2 = new Diff(DiffType.MissingAttribute, mockPath, DiffTargets.Actual);
var diff3 = new Diff(DiffType.MissingAttribute, mockPath, DiffTargets.Actual);
var diffSet = new DiffSet(new[] { diff1, diff2, diff3 });
Assert.IsFalse(diffSet.IsEmpty);
Assert.AreElementsSame(new[] { diff1, diff2, diff3 }, diffSet);
}
public void DetectChangesReturnsTrueIfChangedToNothing()
{
var diffSet = new DiffSet <int>(new[] { 1 });
diffSet.Remove(1);
var result = diffSet.DetectChanges();
Assert.True(result);
}
private static void AddHunk(DiffSet h, Side side, List <Diff3Set> hunks)
{
hunks.Add(new Diff3Set {
Side = side,
File1Offset = h.File1.Offset,
File1Length = h.File1.Length,
File2Offset = h.File2.Offset,
File2Length = h.File2.Length
});
}
protected void AssertDiff(DiffSet actual, params Diff[] expected)
{
Assert.AreEqual(expected.Length == 0, actual.IsEmpty);
Assert.AreElementsEqualIgnoringOrder(expected, actual,
new StructuralEqualityComparer<Diff>
{
x => x.Type,
x => x.Path.ToString(),
});
}
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));
}
protected void AssertDiff(DiffSet actual, params Diff[] expected)
{
Assert.AreEqual(expected.Length == 0, actual.IsEmpty);
Assert.AreElementsEqualIgnoringOrder(expected, actual,
new StructuralEqualityComparer <Diff>
{
x => x.Type,
x => x.Path.ToString(),
});
}
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 Diff_collections_with_several_unexpected_values()
{
var actual = MakeStubCollection("name1", "ERROR1!", "name2", "value2", "name3", "ERROR3!");
var expected = MakeStubCollection("name1", "value1", "name2", "value2", "name3", "value3");
DiffSet diffSet = actual.Diff(expected, XmlPathRoot.Strict.Element(0), XmlPathRoot.Strict.Element(0), XmlOptions.Strict.Value);
AssertDiff(diffSet, new[] {
new Diff(DiffType.UnexpectedAttribute, XmlPathRoot.Strict.Element(0).Attribute(0), DiffTargets.Both),
new Diff(DiffType.UnexpectedAttribute, XmlPathRoot.Strict.Element(0).Attribute(2), DiffTargets.Both)
});
}
public void Constructs_ok()
{
var mockPath = MockRepository.GenerateStub <IXmlPathStrict>();
var diff1 = new Diff(DiffType.MissingAttribute, mockPath, DiffTargets.Actual);
var diff2 = new Diff(DiffType.MissingAttribute, mockPath, DiffTargets.Actual);
var diff3 = new Diff(DiffType.MissingAttribute, mockPath, DiffTargets.Actual);
var diffSet = new DiffSet(new[] { diff1, diff2, diff3 });
Assert.IsFalse(diffSet.IsEmpty);
Assert.AreElementsSame(new[] { diff1, diff2, diff3 }, diffSet);
}
public void DetectChangesReturnsFalseIfItemsAlreadyInSet()
{
var diffSet = new DiffSet<int>(new[] { 0, 10, 20 });
diffSet.Add(0);
diffSet.Add(10);
diffSet.Add(20);
var result = diffSet.DetectChanges();
Assert.False(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);
}
/// <summary>
/// Adds the diff items contained into the specified set to the current set.
/// </summary>
/// <param name="items">The diff items to be added.</param>
/// <returns>A reference to the builder itself.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="items"/> is null.</exception>
public DiffSetBuilder Add(DiffSet items)
{
if (items == null)
throw new ArgumentNullException("items");
foreach (var item in items)
{
Add(item);
}
return this;
}
public void DeleteAtHeadAndInsertAtTail([Column(false, true)] bool optimize)
{
DiffSet diffSet = DiffSet.GetDiffSet("123", "234", optimize, true);
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] {
new Diff(DiffKind.Change, new Range(0, 1), new Range(0, 0)),
new Diff(DiffKind.NoChange, new Range(1, 2), new Range(0, 2)),
new Diff(DiffKind.Change, new Range(3, 0), new Range(2, 1))
}, diffSet.Diffs);
}
public void DetectChangesReturnsFalseIfItemsAlreadyInSet()
{
var diffSet = new DiffSet <int>(new[] { 0, 10, 20 });
diffSet.Add(0);
diffSet.Add(10);
diffSet.Add(20);
var result = diffSet.DetectChanges();
Assert.False(result);
}
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 MultipleAdjacentChanges([Column(false, true)] bool optimize)
{
DiffSet diffSet = DiffSet.GetDiffSet("123abcdef", "abc456def", optimize, true);
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] {
new Diff(DiffKind.Change, new Range(0, 3), new Range(0, 0)),
new Diff(DiffKind.NoChange, new Range(3, 3), new Range(0, 3)),
new Diff(DiffKind.Change, new Range(6, 0), new Range(3, 3)),
new Diff(DiffKind.NoChange, new Range(6, 3), new Range(6, 3))
}, diffSet.Diffs);
}
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 static void DiffSnapshots(DiffOptions o)
{
var snapshotStore = CreateSnapshotStore(o.Repository);
var diff = DiffSet.Create(
snapshotStore.GetSnapshot(o.FirstSnapshotId).BlobReferences,
snapshotStore.GetSnapshot(o.SecondSnapshotId).BlobReferences,
blobReference => blobReference.Name,
(br1, br2) => o.ContentOnly
? br1.ContentUris.SequenceEqual(br2.ContentUris)
: br1.Equals(br2));
PrintDiff(diff);
}
public void ProblemSizeIsReducedButDiffOffsetsAreStillCorrect()
{
DiffSet diffSet = DiffSet.GetDiffSet("123abcZZdef45", "123uvZZxy45");
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] {
new Diff(DiffKind.NoChange, new Range(0, 3), new Range(0, 3)),
new Diff(DiffKind.Change, new Range(3, 3), new Range(3, 2)),
new Diff(DiffKind.NoChange, new Range(6, 2), new Range(5, 2)),
new Diff(DiffKind.Change, new Range(8, 3), new Range(7, 2)),
new Diff(DiffKind.NoChange, new Range(11, 2), new Range(9, 2))
}, diffSet.Diffs);
}
public void Simplify(string leftDocument, string rightDocument, int expectedNumberOfDiffs)
{
DiffSet originalDiffSet = DiffSet.GetDiffSet(leftDocument, rightDocument);
DiffSet simplifiedDiffSet = originalDiffSet.Simplify();
using (TestLog.BeginSection("Original DiffSet"))
originalDiffSet.WriteTo(TestLog.Default);
using (TestLog.BeginSection("Simplified DiffSet"))
simplifiedDiffSet.WriteTo(TestLog.Default);
VerifyDiffSetIsValid(simplifiedDiffSet);
Assert.LessThanOrEqualTo(simplifiedDiffSet.Diffs.Count, originalDiffSet.Diffs.Count);
Assert.AreEqual(expectedNumberOfDiffs, simplifiedDiffSet.Diffs.Count);
}
public void GroupTokenIsNullWhenNoGroups()
{
var response = new PersistentResponse();
var groupSet = new DiffSet<string>(new string[] { });
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: null);
Assert.Null(response.GroupsToken);
}
public void ReadsFromInputAndPassesToConverter()
{
// Arrange
var service = CreateService();
var expected = new FileModification();
var input = new StringReader("abc");
var set = new DiffSet(new FileDiff("Orig", "Mod"));
service.MockReader.Setup(r => r.Read(input)).Returns(set);
service.MockConverter.Setup(c => c.ConvertFile(set.Files.First())).Returns(expected);
// Act
var actual = service.CreateFromGitDiff(input).SingleOrDefault();
// Assert
Assert.Same(expected, actual);
}
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);
}
}
/// <summary>
/// Adds two raw labeled values formatted using <see cref="Formatter" /> and includes
/// formatting of their differences.
/// </summary>
/// <remarks>
/// <para>
/// The order in which this method is called determines the order in which the
/// values will appear relative to other labeled values.
/// </para>
/// </remarks>
/// <param name="leftLabel">The left label.</param>
/// <param name="leftValue">The left value.</param>
/// <param name="rightLabel">The right label.</param>
/// <param name="rightValue">The right value.</param>
/// <returns>The builder, to allow for fluent method chaining.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="leftLabel"/> or
/// <paramref name="rightLabel"/> is null.</exception>
public AssertionFailureBuilder AddRawLabeledValuesWithDiffs(
string leftLabel, object leftValue, string rightLabel, object rightValue)
{
if (leftLabel == null)
{
throw new ArgumentNullException("leftLabel");
}
if (rightLabel == null)
{
throw new ArgumentNullException("rightLabel");
}
if (ReferenceEquals(leftValue, rightValue))
{
AddRawLabeledValue(String.Format("{0} & {1}", leftLabel, rightLabel), leftValue);
AddLabeledValue("Remark", "Both values are the same instance.");
}
else
{
string formattedLeftValue = Formatter.Format(leftValue);
string formattedRightValue = Formatter.Format(rightValue);
if (formattedLeftValue == formattedRightValue)
{
AddLabeledValue(String.Format("{0} & {1}", leftLabel, rightLabel), formattedLeftValue);
AddLabeledValue("Remark", "Both values look the same when formatted but they are distinct instances.");
}
else
{
DiffSet diffSet = DiffSet.GetDiffSet(formattedLeftValue, formattedRightValue);
diffSet = diffSet.Simplify();
var highlightedLeftValueWriter = new StructuredTextWriter();
var highlightedRightValueWriter = new StructuredTextWriter();
diffSet.WriteTo(highlightedLeftValueWriter, DiffStyle.LeftOnly,
formattedLeftValue.Length <= AssertionFailure.MaxFormattedValueLength ? int.MaxValue : CompressedDiffContextLength);
diffSet.WriteTo(highlightedRightValueWriter, DiffStyle.RightOnly,
formattedRightValue.Length <= AssertionFailure.MaxFormattedValueLength ? int.MaxValue : CompressedDiffContextLength);
AddLabeledValue(leftLabel, highlightedLeftValueWriter.ToStructuredText());
AddLabeledValue(rightLabel, highlightedRightValueWriter.ToStructuredText());
}
}
return(this);
}
private static void PrintDiff(DiffSet diff)
{
foreach (var added in diff.Added)
{
Console.WriteLine($"+ {added}");
}
foreach (var changed in diff.Changed)
{
Console.WriteLine($"~ {changed}");
}
foreach (var removed in diff.Removed)
{
Console.WriteLine($"- {removed}");
}
}
public void GroupTokenIsNullWhenNoGroups()
{
var response = new PersistentResponse();
var groupSet = new DiffSet <string>(new string[] { });
var serializer = new JsonNetSerializer();
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: null);
Assert.Null(response.GroupsToken);
}
internal static void VerifyDiffSetIsValid(DiffSet diffSet)
{
foreach (Diff diff in diffSet.Diffs)
{
if (diff.Kind == DiffKind.NoChange)
{
Assert.AreEqual(
diff.LeftRange.SubstringOf(diffSet.LeftDocument),
diff.RightRange.SubstringOf(diffSet.RightDocument));
}
else
{
Assert.AreNotEqual(
diff.LeftRange.SubstringOf(diffSet.LeftDocument),
diff.RightRange.SubstringOf(diffSet.RightDocument));
}
}
}
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 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 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 ShowsLabeledValuesWithDiffs_Difference()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("description");
builder.AddRawLabeledValuesWithDiffs("Left", "acde", "Right", "bcef");
DiffSet diffSet = DiffSet.GetDiffSet("\"acde\"", "\"bcef\"").Simplify();
StructuredTextWriter expectedValueWriter = new StructuredTextWriter();
diffSet.WriteTo(expectedValueWriter, DiffStyle.LeftOnly);
StructuredTextWriter actualValueWriter = new StructuredTextWriter();
diffSet.WriteTo(actualValueWriter, DiffStyle.RightOnly);
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Left", expectedValueWriter.ToStructuredText()),
new AssertionFailure.LabeledValue("Right", actualValueWriter.ToStructuredText())
}, builder.ToAssertionFailure().LabeledValues);
}
public void GroupTokenIsNullWhenNoNewGroups()
{
var response = new PersistentResponse();
var groupSet = new DiffSet<string>(new string[] { "a", "b", "c" });
// Get the first diff
groupSet.GetDiff();
var serializer = new JsonNetSerializer();
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);
Assert.Null(response.GroupsToken);
}
public Connection(IMessageBus newMessageBus,
IJsonSerializer jsonSerializer,
string baseSignal,
string connectionId,
IEnumerable<string> signals,
IEnumerable<string> groups,
ITraceManager traceManager,
IAckHandler ackHandler,
IPerformanceCounterManager performanceCounterManager)
{
_bus = newMessageBus;
_serializer = jsonSerializer;
_baseSignal = baseSignal;
_connectionId = connectionId;
_signals = new HashSet<string>(signals, StringComparer.OrdinalIgnoreCase);
_groups = new DiffSet<string>(groups);
_traceSource = new Lazy<TraceSource>(() => traceManager["SignalR.Connection"]);
_ackHandler = ackHandler;
_counters = performanceCounterManager;
}
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 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 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));
}
internal static void PopulateResponseState(PersistentResponse response,
DiffSet<string> groupSet,
IJsonSerializer serializer,
IProtectedData protectedData)
{
DiffPair<string> groupDiff = groupSet.GetDiff();
if (groupDiff.AnyChanges)
{
// Create a protected payload of the sorted list
IEnumerable<string> groups = groupSet.GetSnapshot();
// No groups so do nothing
if (groups.Any())
{
// Remove group prefixes before any thing goes over the wire
string groupsString = serializer.Stringify(PrefixHelper.RemoveGroupPrefixes(groups));
// The groups token
response.GroupsToken = protectedData.Protect(groupsString, Purposes.Groups);
}
}
}
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 InitializeDiffSetWithChangingIEnumerable()
{
var diffSet = new DiffSet<int>(new NonResettingEnumerator().Ints(5));
Assert.Equal(5, diffSet.GetSnapshot().Count);
for (int i = 0; i < 5; i++ )
{
Assert.True(diffSet.Contains(i));
}
var diffPair = diffSet.GetDiff();
Assert.Equal(5, diffSet.GetSnapshot().Count);
Assert.Equal(5, diffPair.Added.Count);
Assert.Equal(0, diffPair.Removed.Count);
Assert.True(diffPair.Reset);
for (int i = 0; i < 5; i++)
{
Assert.True(diffSet.Contains(i));
Assert.True(diffPair.Added.Contains(i));
Assert.False(diffPair.Removed.Contains(i));
}
}
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 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 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 DetectChangesReturnsTrueIfChangedToNothing()
{
var diffSet = new DiffSet<int>(new[] { 1 });
diffSet.Remove(1);
var result = diffSet.DetectChanges();
Assert.True(result);
}
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));
}
}
internal static void PopulateResponseState(PersistentResponse response,
DiffSet<string> groupSet,
IJsonSerializer serializer,
IProtectedData protectedData,
string connectionId)
{
bool anyChanges = groupSet.DetectChanges();
if (anyChanges)
{
// Create a protected payload of the sorted list
IEnumerable<string> groups = groupSet.GetSnapshot();
// Remove group prefixes before any thing goes over the wire
string groupsString = connectionId + ':' + serializer.Stringify(PrefixHelper.RemoveGroupPrefixes(groups)); ;
// The groups token
response.GroupsToken = protectedData.Protect(groupsString, Purposes.Groups);
}
}
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));
}
}
