public void CanUseTagCacheWhileCreatedOnCurrentThread()
{
//-- arrange
TypeMember typeInt = typeof(int);
TypeMember typeString = typeof(string);
RoslynTypeFactoryBackend.BackendTag intTag1;
RoslynTypeFactoryBackend.BackendTag intTag2;
RoslynTypeFactoryBackend.BackendTag stringTag1;
RoslynTypeFactoryBackend.BackendTag stringTag2;
//-- act
using (TypeMemberTagCache.CreateOnCurrentThread())
{
intTag1 = typeInt.SafeBackendTag();
intTag2 = typeInt.SafeBackendTag();
stringTag1 = typeString.SafeBackendTag();
stringTag2 = typeString.SafeBackendTag();
}
//-- assert
intTag1.Should().NotBeNull();
intTag2.Should().BeSameAs(intTag1);
stringTag1.Should().NotBeNull();
stringTag2.Should().BeSameAs(stringTag1);
intTag1.Should().NotBeSameAs(stringTag1);
}
public void BackendTagsArePerInstanceOfTagCache()
{
//-- arrange
TypeMember typeInt = typeof(int);
//-- act
RoslynTypeFactoryBackend.BackendTag tag1;
RoslynTypeFactoryBackend.BackendTag tag2;
using (TypeMemberTagCache.CreateOnCurrentThread())
{
tag1 = typeInt.SafeBackendTag();
}
using (TypeMemberTagCache.CreateOnCurrentThread())
{
tag2 = typeInt.SafeBackendTag();
}
//-- assert
tag1.Should().NotBeNull();
tag2.Should().NotBeNull();
tag2.Should().NotBeSameAs(tag1);
}
public void CannotCreateTagCacheIfAlreadyExistsOnCurrentThread()
{
//-- act & assert
using (TypeMemberTagCache.CreateOnCurrentThread())
{
Assert.Throws <InvalidOperationException>(() => {
using (TypeMemberTagCache.CreateOnCurrentThread())
{
}
});
}
}
public void CannotUseTagCacheAfterItIsDisposedOnCurrentThread()
{
//-- arrange
TypeMember typeInt = typeof(int);
using (TypeMemberTagCache.CreateOnCurrentThread())
{
}
//-- act & assert
Assert.Throws <InvalidOperationException>(() => {
var tag = typeInt.SafeBackendTag();
});
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected SyntaxEmittingTestBase()
{
_tagCache = TypeMemberTagCache.CreateOnCurrentThread();
}
public void CanGenerateHardCodedArtifactCatalogClass()
{
//-- arrange
var firstArtifactType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "FirstArtifact");
var secondArtifactType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "SecondArtifact");
var catalogType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "ThisAssemblyArtifactCatalog");
catalogType.BaseType = typeof(RuntimeTypeFactoryArtifactCatalog);
var getArtifactsMethod = new MethodMember(
MemberVisibility.Public,
MemberModifier.Override,
nameof(RuntimeTypeFactoryArtifactCatalog.GetArtifacts),
new MethodSignature {
ReturnValue = new MethodParameter {
Type = typeof(RuntimeTypeFactoryArtifact[])
}
});
var artifactsVariable = new LocalVariable {
Name = "artifacts"
};
getArtifactsMethod.Body = new BlockStatement(
new VariableDeclarationStatement {
Variable = artifactsVariable,
InitialValue = new NewArrayExpression {
ElementType = typeof(RuntimeTypeFactoryArtifact),
Length = new ConstantExpression {
Value = 2
}
},
},
new ExpressionStatement {
Expression = new AssignmentExpression {
Left = new IndexerExpression {
Target = new LocalVariableExpression {
Variable = artifactsVariable
},
Index = new ConstantExpression {
Value = 0
}
},
Right = new NewObjectExpression {
Type = firstArtifactType
}
}
},
new ExpressionStatement {
Expression = new AssignmentExpression {
Left = new IndexerExpression {
Target = new LocalVariableExpression {
Variable = artifactsVariable
},
Index = new ConstantExpression {
Value = 1
}
},
Right = new NewObjectExpression {
Type = secondArtifactType
}
}
},
new ReturnStatement {
Expression = new LocalVariableExpression {
Variable = artifactsVariable
}
}
);
catalogType.Members.Add(getArtifactsMethod);
//-- act
var syntaxEmitter = new ClassSyntaxEmitter(catalogType);
SyntaxNode actualSyntax;
using (TypeMemberTagCache.CreateOnCurrentThread())
{
actualSyntax = syntaxEmitter.EmitSyntax();
}
//-- assert
var expectedCode = @"
public class ThisAssemblyArtifactCatalog : NWheels.Compilation.Mechanism.Factories.RuntimeTypeFactoryArtifactCatalog
{
public override NWheels.Compilation.Mechanism.Factories.RuntimeTypeFactoryArtifact[] GetArtifacts()
{
var artifacts = new NWheels.Compilation.Mechanism.Factories.RuntimeTypeFactoryArtifact[2];
artifacts[0] = new FirstArtifact();
artifacts[1] = new SecondArtifact();
return artifacts;
}
}
";
actualSyntax.Should().BeEquivalentToCode(expectedCode);
}
public void CanGenerateHardCodedArtifactClass()
{
//-- arrange
var artifactType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "FirstArtifact");
artifactType.BaseType = new TypeMember(typeof(RuntimeTypeFactoryArtifact <>).MakeGenericType(typeof(IFirstContract)));
artifactType.Interfaces.Add(new TypeMember(typeof(IConstructor <>).MakeGenericType(typeof(IFirstContract))));
var constructor = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, "FirstArtifact", new MethodSignature());
constructor.CallBaseConstructor = new MethodCallExpression();
var typeKeyConstructorCall = new MethodCallExpression();
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = typeof(TestFactory)
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = typeof(IFirstContract)
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression()
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression()
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = 0
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = 0
}
});
typeKeyConstructorCall.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = 0
}
});
constructor.CallBaseConstructor.Arguments.Add(new Argument {
Expression = new NewObjectExpression {
Type = typeof(TypeKey),
ConstructorCall = typeKeyConstructorCall
}
});
constructor.CallBaseConstructor.Arguments.Add(new Argument {
Expression = new ConstantExpression {
Value = typeof(FirstContractImplementation)
}
});
var factoryMethod = new MethodMember(
MemberVisibility.Public,
MemberModifier.None,
nameof(IConstructor <object> .NewInstance),
new MethodSignature {
ReturnValue = new MethodParameter {
Type = typeof(IFirstContract)
}
});
factoryMethod.Body = new BlockStatement(
new ReturnStatement {
Expression = new NewObjectExpression {
Type = typeof(FirstContractImplementation)
}
}
);
var singletonMethod = new MethodMember(
MemberVisibility.Public,
MemberModifier.None,
nameof(IConstructor <object> .GetOrCreateSingleton),
new MethodSignature {
ReturnValue = new MethodParameter {
Type = typeof(IFirstContract)
}
});
singletonMethod.Body = new BlockStatement(
new ThrowStatement {
Exception = new NewObjectExpression {
Type = typeof(NotSupportedException)
}
}
);
artifactType.Members.Add(constructor);
artifactType.Members.Add(factoryMethod);
artifactType.Members.Add(singletonMethod);
//-- act
var syntaxEmitter = new ClassSyntaxEmitter(artifactType);
SyntaxNode actualSyntax;
using (TypeMemberTagCache.CreateOnCurrentThread())
{
actualSyntax = syntaxEmitter.EmitSyntax();
}
//-- assert
var expectedCode = @"
public class FirstArtifact :
NWheels.Compilation.Mechanism.Factories.RuntimeTypeFactoryArtifact<NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract>,
NWheels.Compilation.Mechanism.Factories.IConstructor<NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract>
{
public FirstArtifact() : base(
new NWheels.Compilation.Mechanism.Factories.TypeKey(
typeof(NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.TestFactory),
typeof(NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract),
null, null, 0, 0, 0),
typeof(NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.FirstContractImplementation))
{
}
public NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract NewInstance()
{
return new NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.FirstContractImplementation();
}
public NWheels.Compilation.Adapters.Roslyn.UnitTests.RoslynTypeFactoryBackendTests.IFirstContract GetOrCreateSingleton()
{
throw new System.NotSupportedException();
}
}
";
actualSyntax.Should().BeEquivalentToCode(expectedCode);
}
