public static void ShouldDeepEqual(this object actual, object expected, IComparison comparison, bool recursionProtection = true)
{
var context = new ComparisonContext {
RecursionProtection = recursionProtection
};
var result = comparison.Compare(context, actual, expected);
if (result != ComparisonResult.Fail)
{
return;
}
var sb = new StringBuilder();
sb.Append("Comparison Failed");
if (context.Differences.Count > 0)
{
sb.AppendFormat(": The following {0} differences were found.", context.Differences.Count);
foreach (var difference in context.Differences)
{
var lines = difference.ToString().Split(new[] { "\n" }, StringSplitOptions.None);
sb.Append("\n\t");
sb.Append(string.Join("\n\t", lines));
}
}
throw new Exception(sb.ToString());
}
public static bool IsDeepEqual(this object actual, object expected, IComparison comparison)
{
var context = new ComparisonContext();
var result = comparison.Compare(context, actual, expected);
return(result == ComparisonResult.Pass);
}
public static bool IsDeepEqual(this object actual, object expected, IComparison comparison, bool recursionProtection = true)
{
var context = new ComparisonContext {
RecursionProtection = recursionProtection
};
var result = comparison.Compare(context, actual, expected);
return(result == ComparisonResult.Pass);
}
public static bool IsDeepEqual(this object actual, object expected, IComparison comparison)
{
comparison = comparison ?? new ComparisonBuilder().Create();
var context = new ComparisonContext();
var(result, _) = comparison.Compare(context, actual, expected);
return(result != ComparisonResult.Fail);
}
protected override bool CompareImp(
string input,
int pos,
int depth,
RunState runState)
{
bool rv = !m_Comparison.Compare(input, pos, depth + 1, runState);
return(rv);
}
public bool Equals(object x, object y)
{
var result = comparison.Compare(context, x, y);
results.Add(result.result);
// Objects without properties is compared to inconclusive by default by DeepEqual library, for testing Inconclusive means pass.
// Equals cannot return Inconclusive, so this comparer would always either pass or fail and not continue to the next comparer for
// further inspection. Therefore we always return true and consult the Results property afterwards.
// Later we can adopt the DeepEquals library and change the default behavior for empty objects, so that they will pass instead of
// be inconclusive when they are compared.
return(true);
}
public static void ShouldDeepEqual(this object actual, object expected, IComparison comparison)
{
comparison = comparison ?? new ComparisonBuilder().Create();
var context = new ComparisonContext();
var result = comparison.Compare(context, actual, expected);
if (result != ComparisonResult.Fail)
{
return;
}
throw new DeepEqualException(context);
}
protected override bool CompareAndAdvanceImp(
string input,
int pos,
int depth,
RunState runState,
out int index)
{
#if DEBUG
if (pos == 1720)
{
}
#endif
index = pos;
bool rv = m_Comparison.Compare(input, pos, depth, runState);
if (rv)
{
}
return(rv);
}
public static void ShouldDeepEqual(
this object actual,
object expected,
IComparison comparison,
IDifferenceFormatterFactory formatterFactory)
{
var builder = new ComparisonBuilder();
comparison = comparison ?? builder.Create();
formatterFactory = formatterFactory ?? builder.GetFormatterFactory();
var context = new ComparisonContext();
var(result, newContext) = comparison.Compare(context, actual, expected);
if (result != ComparisonResult.Fail)
{
return;
}
var message = new DeepEqualExceptionMessageBuilder(newContext, formatterFactory).GetMessage();
throw new DeepEqualException(message, newContext);
}
public T[] FastSort(T[] a, IComparison <T> comp)
{
if (a.Length == 0)
{
return(a);
}
else
{
if (a.Length <= 2)
{
if (a.Length == 1)
{
return(a);
}
else
{
int compi = comp.Compare(a[0], a[1]);
T[] b = new T[a.Length];
if (compi == 2)
{
return(a);
}
else if (compi == 3)
{
b[0] = a[0];
b[1] = a[1];
return(b);
}
else
{
b[0] = a[1];
b[1] = a[0];
return(b);
}
}
}
else
{
T[] b = new T[0];
T[] c = new T[0];
T[] d = new T[0];
System.Console.WriteLine("gena");
for (int i = 1; i < a.Length; i++)
{
int compi = comp.Compare(a[0], a[i]);
if (compi == 1)
{
Array.Resize(ref c, c.Length + 1);
c[c.Length - 1] = a[i];
}
else if (compi == 2)
{
Array.Resize(ref d, d.Length + 1);
d[d.Length - 1] = a[i];
}
else
{
Array.Resize(ref b, b.Length + 1);
b[b.Length - 1] = a[i];
}
}
Array.Resize(ref d, d.Length + 1);
d[d.Length - 1] = a[0];
b = FastSort(b, comp);
c = FastSort(c, comp);
if (b == null & d == null)
{
return(c);
}
else if (c == null & d == null)
{
return(b);
}
else if (c == null & b == null)
{
return(d);
}
else
{
var z = new T[d.Length + c.Length];
c.CopyTo(z, 0);
d.CopyTo(z, c.Length);
var g = new T[z.Length + b.Length];
z.CopyTo(g, 0);
b.CopyTo(g, z.Length);
return(g);
}
}
}
}
protected override bool CompareAndAdvanceImp(
string str,
int firstIndex,
int depth,
RunState runState,
out int index)
{
index = -1;
// Statement index
int stmtIndex;
bool failedMatch = false;
int pos;
int depthPlusOne = depth + 1;
for (stmtIndex = 0, pos = firstIndex; !failedMatch && stmtIndex < m_Statements.Count;
++stmtIndex)
{
// Key nuance design decision. It's OK to perform operations/comparisons even if we have reached the end of
// the string. This is necessary for things like setting variables, comparing against the end of the
// string e.t.c. No doubt there will be bugs presuming this isn't the case but I've only realised
// retrospectively that this is a requirement.
IStatement stmt = m_Statements[stmtIndex];
if (stmt is IOperation)
{
IOperation op = (IOperation)stmt;
op.Perform(str, pos, depthPlusOne, runState, out pos);
}
else
{
if (stmt is IComparisonWithAdvance)
{
IComparisonWithAdvance comp = (IComparisonWithAdvance)stmt;
int previousPos = pos;
if (!comp.CompareAndAdvance(str, pos, depthPlusOne, runState, out pos))
{
// This part of the pattern match failed. Start again (using the outer loop/index) but at
// the next character
failedMatch = true;
}
}
else if (stmt is IComparison)
{
//sidtodo not sure about this - I'm not sure the design of the statement classes is right
IComparison comp = (IComparison)stmt;
if (!comp.Compare(str, pos, depthPlusOne, runState))
{
failedMatch = true;
}
}
}
}
// Got this far without a match?
if (!failedMatch)
{
// Did we execute all statements?
if (stmtIndex == m_Statements.Count)
{
// Exclusions?
if (Exclusion != null)
{
string subStr = str.Substring(firstIndex, pos - firstIndex);
failedMatch = Exclusion.Compare(subStr, 0, depthPlusOne, runState);
}
if (!failedMatch)
{
// Successful match
index = pos;
}
}
else
{
// We did not complete all of the comparisons
// Go to the next character
// Potentially a speedup here? If we reach the end of the input string but cannot complete all
// comparisons then copy the remaining string rather than trying to do any more comparisons?
failedMatch = true;
}
}
return(!failedMatch);
}
