public void MergeWithNullKeysSucceeds()
{
var wordsA = new[] { "car", "dog", "free", null };
var wordsB = new[] { "car", "dog", "free", "sixpack" };
var uniqueA = new HashSet<string>();
var uniqueB = new HashSet<string>();
var pairs = new HashSet<string>();
wordsA.Merge(
wordsB,
a => a,
b => b,
a => uniqueA.Add(a),
b => uniqueB.Add(b),
(a, b) => pairs.Add(a)
);
Assert.AreEqual(1, uniqueA.Count);
Assert.IsTrue(uniqueA.Contains(null));
Assert.AreEqual(1, uniqueB.Count);
Assert.IsTrue(uniqueB.Contains("sixpack"));
Assert.AreEqual(3, pairs.Count);
Assert.IsTrue(pairs.Contains("car"));
Assert.IsTrue(pairs.Contains("dog"));
Assert.IsTrue(pairs.Contains("free"));
}
public void SimpleMergeSucceeds()
{
var lengths = new[] { 1, 3, 4, 6 };
var words = new[] { "car", "dog", "free", "sixpack" };
var uniqueLengths = new HashSet<int>();
var uniqueWords = new HashSet<string>();
var pairs = new HashSet<Tuple<int, string>>();
lengths.Merge(
words,
l => l,
w => w.Length,
l => uniqueLengths.Add(l),
w => uniqueWords.Add(w),
(l, w) => pairs.Add(Tuple.Create(l, w))
);
Assert.AreEqual(2, uniqueLengths.Count);
Assert.IsTrue(uniqueLengths.Contains(1));
Assert.IsTrue(uniqueLengths.Contains(6));
Assert.AreEqual(1, uniqueWords.Count);
Assert.IsTrue(uniqueWords.Contains("sixpack"));
Assert.AreEqual(3, pairs.Count);
Assert.IsTrue(pairs.Contains(Tuple.Create(3, "car")));
Assert.IsTrue(pairs.Contains(Tuple.Create(3, "dog")));
Assert.IsTrue(pairs.Contains(Tuple.Create(4, "free")));
}
private static void Merge(System.Data.DataTable DestTable, System.Data.DataTable SrcTable)
{
string pk = DestTable.PrimaryKey[0].ColumnName;
System.Data.DataRow[] pkChangedRows = DestTable.AsEnumerable().Where(p => p.RowState == DataRowState.Modified
&& !p[pk, DataRowVersion.Original].Equals(p[pk, DataRowVersion.Current])).ToArray();
try
{
//When PK has changed, move row to added state
foreach (System.Data.DataRow dr in pkChangedRows)
{
dr.AcceptChanges();
dr.SetAdded();
}
DestTable.Merge(SrcTable);
}
finally
{
//And when back to modifyed
foreach (System.Data.DataRow dr in pkChangedRows)
{
dr.AcceptChanges();
dr.SetModified();
}
}
}
public void Merge_PassedInconclusiveAndFailedResults_ShouldReturnFailed()
{
var testResults = new[] { TestResult.Passed, TestResult.Inconclusive, TestResult.Failed };
TestResult actual = testResults.Merge();
Check.That(actual).Equals(TestResult.Failed);
}
public void Merge_MultiplePassedOneInconclusiveResults_ShouldReturnInconclusive()
{
var testResults = new[] { TestResult.Passed, TestResult.Passed, TestResult.Inconclusive };
TestResult actual = testResults.Merge();
Check.That(actual).Equals(TestResult.Inconclusive);
}
public void Merge_MultiplePassedResults_ShouldReturnPassed()
{
var testResults = new[] { TestResult.Passed, TestResult.Passed };
TestResult actual = testResults.Merge();
Check.That(actual).Equals(TestResult.Passed);
}
public void Merge_MultiplePassedResults_ShouldReturnPassed()
{
var testResults = new[] { TestResult.Passed, TestResult.Passed };
TestResult actual = testResults.Merge();
actual.ShouldEqual(TestResult.Passed);
}
public void Merge_SingleItem_ReturnsThatItem()
{
var testResults = new[]
{
TestResult.Passed
};
TestResult actual = testResults.Merge();
Check.That(actual).Equals(TestResult.Passed);
}
public void Merge_MultipleItemsWasExecutedTrueAndTrue_ReturnsWasExecutedTrue()
{
var testResults = new[]
{
new TestResult { WasExecuted = true }, new TestResult { WasExecuted = true }
};
TestResult actual = testResults.Merge();
actual.WasExecuted.ShouldBeTrue();
}
internal static IObservable<FileSystemEventArgs> AsObservable(this FileSystemWatcher fileSystemWatcher)
{
var allObservables = new[]
{
fileSystemWatcher.GetChanged().Select(p => p.EventArgs),
fileSystemWatcher.GetCreated().Select(p => p.EventArgs),
fileSystemWatcher.GetDeleted().Select(p => p.EventArgs),
fileSystemWatcher.GetRenamed().Select(p => p.EventArgs)
};
return allObservables.Merge();
}
public void Merge_SingleItem_ReturnsThatItem()
{
var testResults = new[]
{
new TestResult { WasExecuted = true, WasSuccessful = false }
};
TestResult actual = testResults.Merge();
actual.WasExecuted.ShouldBeTrue();
actual.WasSuccessful.ShouldBeFalse();
}
public static void Test3()
{
var x = new[] { "a", "c", "d", "i", "j", "k", "s", "w", "x", "z" };
var y = new[] { "b", "q", "t", "y" };
foreach (var s in x.Merge(y, StringComparer.Ordinal))
{
Console.Write($"{s} ");
}
Console.WriteLine();
Console.WriteLine("----------------------------");
}
public void Merge_MultipleItemsWasSuccessfulTrueAndFalse_ReturnsWasSuccessfulFalse()
{
var testResults = new[]
{
new TestResult { WasSuccessful = true },
new TestResult { WasSuccessful = false }
};
TestResult actual = testResults.Merge();
actual.WasSuccessful.ShouldBeFalse();
}
public void SimpleMergeUsingFluentSyntaxSucceeds()
{
var lengths = new[] { 1, 3, 4, 6 };
var words = new[] { "car", "dog", "free", "sixpack" };
var uniqueLengths = new HashSet<int>();
var uniqueWords = new HashSet<string>();
var pairs = new HashSet<Tuple<int, string>>();
lengths.Merge(words, m => m
.OuterKey(l => l)
.InnerKey(w => w.Length)
.WhenNotMatchedByInner(l => uniqueLengths.Add(l))
.WhenNotMatchedByOuter(w => uniqueWords.Add(w))
.WhenMatched((l, w) => pairs.Add(Tuple.Create(l, w)))
);
Assert.AreEqual(2, uniqueLengths.Count);
Assert.IsTrue(uniqueLengths.Contains(1));
Assert.IsTrue(uniqueLengths.Contains(6));
Assert.AreEqual(1, uniqueWords.Count);
Assert.IsTrue(uniqueWords.Contains("sixpack"));
Assert.AreEqual(3, pairs.Count);
Assert.IsTrue(pairs.Contains(Tuple.Create(3, "car")));
Assert.IsTrue(pairs.Contains(Tuple.Create(3, "dog")));
Assert.IsTrue(pairs.Contains(Tuple.Create(4, "free")));
}
public void Merge_SingleItem_ReturnsThatItem()
{
var testResults = new[]
{
TestResult.Passed
};
TestResult actual = testResults.Merge();
actual.ShouldEqual(TestResult.Passed);
}
public static string Escape(string value)
{
if (String.IsNullOrEmpty(value))
{
return String.Empty;
}
var chars = new List<char>(value.Length);
var search = new[] {'"', '\'', '/', '\\'};
var ignored = new[] {'b', 'f', 'n', 'r', 't', 'u', 'v'};
ignored = search.Merge(ignored);
char prev, next;
value.For(
(i, c) =>
{
if (search.Any(sc => sc == c))
{
if (c == '\\')
{
if (i == 0)
{
if (i + 1 < value.Length)
{
next = value[i + 1];
if (!ignored.Any(ic => ic == next))
{
chars.Add('\\');
}
}
else
{
chars.Add('\\');
}
}
else
{
prev = value[i - 1];
if (i + 1 < value.Length)
{
next = value[i + 1];
if (prev != '\\' && !ignored.Any(ic => ic == next))
{
chars.Add('\\');
}
}
else if (prev != '\\')
{
chars.Add('\\');
}
}
}
else
{
if (i == 0)
{
chars.Add('\\');
}
else
{
prev = value[i - 1];
if (prev != '\\')
{
chars.Add('\\');
}
}
}
}
chars.Add(c);
});
return new string(chars.ToArray());
}
