/// <summary>
/// Initializes a new <see cref="MSTestAutomation"/>.
/// </summary>
public MSTestAutomation(TestMethod testMethod)
{
Name = $"{testMethod.FullClassName}.{testMethod.Name}";
Identifier = IdentifierFactory.CreateIdentifier(Name);
Storage = Path.GetFileName(testMethod.AssemblyName);
TestType = "Unit Test";
}
/// <summary>
/// Initializes a new <see cref="NUnitTestAutomation"/>.
/// </summary>
public NUnitTestAutomation(XElement testNode, XElement containerNode)
{
Name = testNode.Attribute("fullname").Value;
Identifier = IdentifierFactory.CreateIdentifier(Name);
Storage = Path.GetFileName(containerNode.Attribute("fullname").Value);
TestType = "Unit Test";
}
public void Analyze <TItem>(EngineImplementations <TItem> implementations, IdentifierDefinition definition)
where TItem : class
{
var factory = new IdentifierFactory <TItem>(definition);
implementations.IdentifierFactories.Add(definition.IdentifierName, factory);
}
/// <summary>
/// Initializes a new <see cref="XunitTestAutomation"/>.
/// </summary>
/// <param name="testCase">An xUnit test case</param>
/// <param name="testAssembly">The assembly containing the test case</param>
public XunitTestAutomation(ITestCase testCase, ITestAssembly testAssembly)
{
Name = testCase.DisplayName;
Identifier = IdentifierFactory.CreateIdentifier(Name);
Storage = Path.GetFileName(testAssembly.Assembly.AssemblyPath);
TestType = "Unit Test";
}
private string GetMethodName(BaseMethodDeclarationSyntax node)
{
string result;
var type = node.GetType();
if (type == typeof(MethodDeclarationSyntax))
{
var method = node as MethodDeclarationSyntax;
result = method.Identifier.ToString();
}
else if (type == typeof(OperatorDeclarationSyntax))
{
var op = node as OperatorDeclarationSyntax;
result = op.UnderlyingMethodName();
}
else if (type == typeof(ConversionOperatorDeclarationSyntax))
{
var conv = node as ConversionOperatorDeclarationSyntax;
result = conv.UnderlyingMethodName();
}
else
{
throw new NotSupportedException($"Unsupported node type. ({node.GetType()})");
}
result = result + "_InnerIterator";
result = IdentifierFactory.CreateUnique(UsedIdentifiers, result);
UsedIdentifiers.Add(result);
return(result);
}
private TTypeNode VisitMembers <TTypeNode>(TTypeNode node)
where TTypeNode : CSharpSyntaxNode
{
UsedIdentifiers = IdentifierFactory.GetUsedIdentifiers(node, model).ToList();
return(nodeRewriter
.Try(node, ExpandTypeMembers, "Expanded members")
.Result);
}
private static StatementSyntax PostconditionStatement(IEnumerable <Contract> contracts, ITypeSymbol type, ReturnStatementSyntax node, SemanticModel model)
{
var returnedExpression = node.ChildNodes().FirstOrDefault().ToString();
var tempVariableName = IdentifierFactory.CreatePostconditionLocal(node, model);
return(Block(ParseStatement(
GetPostconditionText(contracts, type, returnedExpression, tempVariableName))));
}
private string GetFieldName(PropertyDeclarationSyntax node)
{
var propertyName = node.Identifier.ToString();
var result = IdentifierFactory.CreateUnique(UsedIdentifiers, $"_{propertyName}");
UsedIdentifiers.Add(result);
return(result);
}
public MidScalarizeOutputs(
IdentifierFactory identifiers,
MidExpFactory exps)
{
_identifiers = identifiers;
_exps = exps;
_replacePass = new ReplacePass(_exps);
}
public MidScalarizeOutputs(
IdentifierFactory identifiers,
MidExpFactory exps )
{
_identifiers = identifiers;
_exps = exps;
_replacePass = new ReplacePass( _exps );
}
/// <summary>
/// Constructs a Message for the given <code>payload</code> and <code>meta data</code>. The given <code>metaData</code> is
/// merged with the MetaData from the correlation data of the current unit of work, if present.
/// </summary>
/// <param name="declaredPayloadType">The declared type of message payload</param>
/// <param name="payload">The payload for the message</param>
/// <param name="metaData">The meta data for the message</param>
public GenericMessage(Type declaredPayloadType,
T?payload,
IImmutableDictionary <string, object> metaData) : this(
IdentifierFactory.GetInstance().GenerateIdentifier(),
declaredPayloadType,
payload,
CurrentUnitOfWork <IMessage <T>, T> .CorrelationData().MergedWith(MetaData.From(metaData))
)
{
}
public MidLocalEmitEnv(
MidEmitEnv parent,
IdentifierFactory identifiers,
MidElementDecl element,
MidExpFactory exps)
: base(parent)
{
_identifiers = identifiers;
_element = element;
_exps = exps;
}
public static IEnumerable <IGremlinQuery <string> > CreateSchemaQueries(this IDseGraphModel model)
{
var identifierFactory = IdentifierFactory.CreateDefault();
model = model
.EdgeConnectionClosure();
return(model
.CreatePropertyKeyQueries()
.Concat(model.CreateVertexLabelQueries())
.Concat(model.CreateVertexMaterializedIndexQueries(identifierFactory))
.Concat(model.CreateVertexSecondaryIndexQueries(identifierFactory))
.Concat(model.CreateVertexSearchIndexQueries())
.Concat(model.CreateEdgeLabelQueries())
.Concat(model.CreateEdgeIndexQueries(identifierFactory)));
}
public SharedContextHLSL(
IdentifierFactory identifiers,
IDiagnosticsCollection diagnostics)
{
_identifiers = identifiers;
_diagnostics = diagnostics;
}
public MidEmitContext(IdentifierFactory identifiers)
{
_identifiers = identifiers;
_exps = new MidExpFactory(_lazy);
}
