public static string GenerateTestFilename(IAssertionTool tool, int stackDepth = 1)
{
var frame = new StackFrame(stackDepth, false);
var mi = frame.GetMethod();
var name = mi.Name;
// For local methods and anonymous types, the C# compiler creates a name that includes the enclosing method name
// a type like Action ex = ()=>true;
// <GenerateTestFilename>b_0001
// so we want to just pull the enclosing method name (enclosed in < and >) and not worry about any of the compiler
// generated stuff that can change unpredictably during development
if (name.StartsWith("<"))
{
int idx = 1;
while (name.IndexOf('<', idx) == idx)
{
idx++;
}
name = name.Substring(1, name.IndexOf('>') - 1);
}
var declaringType = frame.GetMethod().DeclaringType;
if (Attribute.IsDefined(declaringType, typeof(CompilerGeneratedAttribute)))
{
var type2 = declaringType.DeclaringType;
declaringType = type2 ?? declaringType;
}
var fullName = declaringType.FullName + "." + name;
var sanitized = SanitizeFilename(tool, fullName);
return(sanitized);
}
public virtual void Init()
{
_assert = ExpressiveAssertions.Tooling.AssertionRendererTool.Create(
CompositeAssertionTool.Create(
ExpressiveAssertions.Tooling.AssertionRendererTool.Create(
TraceLoggingAssertionTool.Create()
),
_introspective = new IntrospectiveAssertionTool(
ExpressiveAssertions.Tooling.AssertionRendererTool.Create(
CompositeAssertionTool.Create(
TraceLoggingAssertionTool.Create(),
ExpressiveAssertions.MSTest.MSTestAssertionTool.Create()
)
)
)
)
);
FilesystemAssertionRepository.SetFilesystemFilenameRemovePrefix(_assert, "ExpressiveAssertions.Tests.");
var assertPath = System.IO.Path.Combine("..", "..", "..", "assertions",
FilesystemAssertionRepository.SanitizeFilename(_assert, TestContext.FullyQualifiedTestClassName),
FilesystemAssertionRepository.SanitizeFilename(_assert, TestContext.TestName)
);
FilesystemAssertionRepository.SetFilesystemAssertionRepositoryPath(_assert, assertPath);
}
public static void EachSorted <T>(this IAssertionTool assertTool, Expression <Func <IEnumerable <T> > > expectedExp, Expression <Func <IEnumerable <T> > > actualExp, Expression <Action <IAssertionTool, T, T> > action, string msg, params object[] fmt)
{
if (string.IsNullOrWhiteSpace(msg))
{
msg = string.Empty;
fmt = fmt ?? new object[] { };
}
else if (fmt == null)
{
fmt = new object[] { msg };
msg = "{0}";
}
var evaluator = assertTool.GetExpressionEvaluator();
var context = assertTool.ContextGet();
var expected = evaluator.Eval(expectedExp);
var actual = evaluator.Eval(actualExp);
using (var eenum = expected.GetEnumerator())
using (var aenum = actual.GetEnumerator())
{
int i;
bool enext = false, anext = false;
using (context.Push())
{
if (!string.IsNullOrWhiteSpace(msg))
{
context.Set("Message", string.Format(msg, fmt));
}
for (i = 0; (enext = eenum.MoveNext()) && (anext = aenum.MoveNext()); i++)
{
context.Set("Element Index", i.ToString());
evaluator.Eval(action, assertTool, eenum.Current, aenum.Current);
}
}
if (enext != anext)
{
int c = i;
if (enext)
{
while (eenum.MoveNext())
{
c++;
}
assertTool.AreEqual(c, i, "Element Count Doesn't Match. " + msg, fmt);
}
else
{
while (aenum.MoveNext())
{
c++;
}
assertTool.AreEqual(i, c, "Element Count Doesn't Match. " + msg, fmt);
}
}
}
}
public static void Each <T>(this IAssertionTool assertTool, Expression <Func <IEnumerable <T> > > collectionExp, Expression <Action <IAssertionTool, T> > action, string msg, params object[] fmt)
{
if (string.IsNullOrWhiteSpace(msg))
{
msg = string.Empty;
fmt = fmt ?? new object[] { };
}
else if (fmt == null)
{
fmt = new object[] { msg };
msg = "{0}";
}
var evaluator = assertTool.GetExpressionEvaluator();
var context = assertTool.ContextGet();
using (context.Push())
{
context.Set("Message", string.Format(msg, fmt));
var collection = evaluator.Eval(collectionExp);
foreach (var ele in collection.Select((e, i) => new { e, i }))
{
context.Set("Element Index", ele.i.ToString());
evaluator.Eval(action, assertTool, ele.e);
}
}
}
public static void Throws <T>(this IAssertionTool assertTool, Expression <Func <object> > test, Exception exc, string message, params object[] fmt)
{
if (fmt == null)
{
fmt = new object[] { };
}
if (fmt.Length <= 0)
{
fmt = new object[] { message };
message = "{0}";
}
Exception internalError = null;
try
{
assertTool.GetExpressionEvaluator().Eval(test);
}
catch (Exception eError)
{
internalError = eError;
}
if (internalError is T)
{
assertTool.Accept(new AssertionSuccess(test.Body, null, null, null, null, message, fmt, exc, internalError, assertTool.ContextGetData()));
}
else
{
assertTool.Accept(new AssertionFailure(test.Body, null, null, null, null, message, fmt, exc, internalError, assertTool.ContextGetData()));
}
}
public static string GetFilesystemAssertionExpectedSuffix(IAssertionTool tool)
{
if (!TryGetContext <string>(tool, EXPECTED_SUFFIX_CTX, out var suffix))
{
return(".expected");
}
return(suffix);
}
public static void IsEmpty <T>(this IAssertionTool assertTool, Expression <Func <IEnumerable <T> > > collection, string msg, params object[] fmt)
{
var xgr = new ExpressionGenerator();
var eval = assertTool.GetExpressionEvaluator();
var exp = xgr.FromFunc(collection, c => c.Count());
assertTool.AreEqual(0, exp, msg, fmt);
}
public static int GetFilesystemFilenameMaxLength(IAssertionTool tool)
{
if (!TryGetContext <int>(tool, ASSERT_FILENAME_MAXLEN, out var maxlen))
{
return(80);
}
return(maxlen);
}
public static string GetFilesystemAssertionActualSuffix(IAssertionTool tool)
{
if (!TryGetContext <string>(tool, ACTUAL_SUFFIX_CTX, out var suffix))
{
return(".actual");
}
return(suffix);
}
public static byte[][] GetFilesystemAssertionActualFilters(IAssertionTool tool)
{
if (!TryGetContext <byte[][]>(tool, ACTUAL_FILTERS, out var filters))
{
return(new byte[0][]);
}
return(filters);
}
public static string GetFilesystemFilenameRemovePrefix(IAssertionTool tool)
{
if (!TryGetContext <string>(tool, ASSERT_FILENAME_REMOVE_PREFIX, out var prefix))
{
return(string.Empty);
}
return(prefix);
}
public static void AddFilesystemAssertionActualFilter(IAssertionTool tool, byte[] filter)
{
var current = GetFilesystemAssertionActualFilters(tool);
Array.Resize(ref current, current.Length + 1);
current[current.Length - 1] = filter;
SetFilesystemAssertionActualFilters(tool, current);
}
public static string GetFilesystemAssertionRepositoryPath(IAssertionTool tool)
{
if (!TryGetContext <string>(tool, PATH_CTX, out var path))
{
return(string.Empty);
}
return(path);
}
public static int GetFilesystemAssertionCount(IAssertionTool tool)
{
if (!TryGetContext <int>(tool, ASSERT_COUNT_CTX, out var count))
{
return(0);
}
return(count);
}
public static int AdvanceFilesystemAssertionCount(IAssertionTool tool)
{
int count = GetFilesystemAssertionCount(tool);
count += 1;
SetContext(tool, ASSERT_COUNT_CTX, count);
return(count);
}
public static IAssertionContext ContextGet(this IAssertionTool assertTool)
{
IAssertionContext result;
if (!_CONTEXT.TryGetValue(assertTool, out result))
{
_CONTEXT.Add(assertTool, result = new AssertionContext());
}
return(result);
}
public static IExpressionEvaluator GetExpressionEvaluator(this IAssertionTool assertTool)
{
IExpressionEvaluator result;
if (!_EVALUATORS.TryGetValue(assertTool, out result))
{
_EVALUATORS.Add(assertTool, result = new DefaultEvaluator());
}
return(result);
}
public static IAssertionTool ContextSet(this IAssertionTool assertTool, IAssertionContext ctx)
{
IAssertionContext tmp;
if (_CONTEXT.TryGetValue(assertTool, out tmp))
{
_CONTEXT.Remove(assertTool);
}
_CONTEXT.Add(assertTool, ctx);
return(assertTool);
}
public static IAssertionTool SetExpressionEvaluator(this IAssertionTool assertTool, IExpressionEvaluator eval)
{
IExpressionEvaluator tmp;
if (_EVALUATORS.TryGetValue(assertTool, out tmp))
{
_EVALUATORS.Remove(assertTool);
}
_EVALUATORS.Add(assertTool, eval);
return(assertTool);
}
public static Expression <Func <T> > ExpectationFromDisk <T>(this IAssertionTool tool, Func <byte[], T> fromDisk = null, int stackDepth = 2)
{
string filename = GenerateTestFilename(tool, stackDepth);
filename = string.Format("{3}{0}.{1}{2}", filename, AdvanceFilesystemAssertionCount(tool), GetFilesystemAssertionExpectedSuffix(tool), GetFilesystemAssertionFilenamePrefix(tool));
filename = Path.Combine(GetFilesystemAssertionRepositoryPath(tool), filename);
EnsureDirectory(filename);
if (fromDisk == null)
{
fromDisk = d => (T)Convert.ChangeType(Encoding.UTF8.GetString(d), typeof(T));
}
return(() => AccessExpectation <T>(filename, fromDisk, tool));
}
public static void EachIsDistinct <T>(this IAssertionTool assertTool, Expression <Func <IEnumerable <T> > > collectionExp, string msg, params object[] fmt)
{
var set = new HashSet <T>();
Func <IAssertionTool, T, bool> isDistinct = (assert, t) => {
if (set.Contains(t))
{
return(false);
}
set.Add(t);
return(true);
};
assertTool.Each(collectionExp, (assert, t) => assert.IsTrue(() => isDistinct(assert, t)), msg, fmt);
}
static bool TryGetContext <T>(IAssertionTool tool, string key, out T val)
{
var dict = _context.GetOrCreateValue(tool);
var res = dict.TryGetValue(key, out var obj);
if (res)
{
val = (T)obj;
}
else
{
val = default(T);
}
return(res);
}
public TestBase()
{
_log = new ExceptionHandlingLogStream(new UniquenessCodeGeneratorLogStream(new ExceptionFormatterLogStream(new DefaultTextLogStreamFormatter(
CompositeLogStream.Create(
// Filter all errors and alerts to stderr
FilterManager.CreateStream(
new StderrLogStream(),
FilterManager.CreateFilter(lt => false, lt => false, lt => false, lt => false, null, null, lt => false, (lt, ct) => false)
),
// everything else to stdout
FilterManager.CreateStream(
new StdoutLogStream(),
FilterManager.CreateFilter(null, null, null, null, lt => false, lt => false, null, null)
)
)
))));
_assert = ExpressiveAssertions.Tooling.ShortAssertionRendererTool.Create(
ExpressiveAssertions.MSTest.MSTestAssertionTool.Create()
);
}
public static Expression <Func <T> > ActualToDisk <T>(this IAssertionTool tool, Expression <Func <T> > content, Func <T, byte[]> toDisk = null, int stackDepth = 2)
{
string filename = GenerateTestFilename(tool, stackDepth);
filename = string.Format("{3}{0}.{1}{2}", filename, GetFilesystemAssertionCount(tool), GetFilesystemAssertionActualSuffix(tool), GetFilesystemAssertionFilenamePrefix(tool));
filename = Path.Combine(GetFilesystemAssertionRepositoryPath(tool), filename);
EnsureDirectory(filename);
if (toDisk == null)
{
toDisk = d => Encoding.UTF8.GetBytes(Convert.ToString(d));
}
var xgr = new ExpressionGenerator();
var content2 = xgr.FromFunc(
content,
c => WriteActualToDisk <T>(filename, c, toDisk, tool)
);
return(content2);
}
public virtual void Init()
{
_assert = ExpressiveAssertions.Tooling.AssertionRendererTool.Create(
CompositeAssertionTool.Create(
ExpressiveAssertions.Tooling.AssertionRendererTool.Create(
TraceLoggingAssertionTool.Create()
),
_introspective = new IntrospectiveAssertionTool(
ExpressiveAssertions.Tooling.AssertionRendererTool.Create(
CompositeAssertionTool.Create(
TraceLoggingAssertionTool.Create(),
ExpressiveAssertions.MSTest.MSTestAssertionTool.Create()
)
)
)
)
);
var evaluator = new DateTimeNormalizationEvaluator(new DefaultEvaluator());
_assert.SetExpressionEvaluator(evaluator);
}
public void ReplayWhere(IAssertionTool tool, Func <AssertionData, int, bool> condition, string msg, params object[] fmt)
{
List <Exception> errors = new List <Exception>();
foreach (var d in _memory.Where(condition))
{
try
{
d.Visit(tool);
}
catch (Exception eError)
{
errors.Add(eError);
}
}
if (errors.Any())
{
tool.Accept(new AssertionFailure(
null, null, null, null, null,
msg, fmt, new AggregateException("One or more errors ocurred while replaying assertion set", errors), null,
tool.ContextGetData()));
}
}
public override void Visit(IAssertionTool tool)
{
tool.Accept(this);
}
public static void Each <T>(this IAssertionTool assertTool, IEnumerable <T> collection, Expression <Action <IAssertionTool, T> > action, string msg)
{
Each(assertTool, () => collection, action, msg, null);
}
public abstract void Visit(IAssertionTool tool);
public static void Every <T>(this IAssertionTool assertTool, IEnumerable <T> collection, Expression <Action <IAssertionTool, T> > action)
{
Each(assertTool, () => collection, action, null, null);
}
