public void SharedSourceFiles_Methods()
{
string projectPath = null;
string outputPath = null;
TestHelper.GetProjectPaths("SFT", out projectPath, out outputPath);
string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
List <string> sourceFiles = CodeGenHelper.ClientClassLibSourceFiles(clientProjectPath);
ConsoleLogger logger = new ConsoleLogger();
FilenameMap filenameMap = new FilenameMap();
using (SourceFileLocationService locationService = new SourceFileLocationService(new[] { new PdbSourceFileProviderFactory(/*symbolSearchPath*/ null, logger) }, filenameMap))
{
SharedSourceFiles ssf = new SharedSourceFiles(locationService, filenameMap, sourceFiles);
int[] fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateMethodKey(typeof(TestValidator).GetMethod("IsValid")));
Assert.IsNotNull(fileIds, "Expected TestValidator.IsValid to have non-null file ID's because it is shared");
Assert.AreEqual(1, fileIds.Length, "Expected TestValidator.IsValid to be found in exactly one file");
Assert.IsTrue(filenameMap[fileIds[0]].Contains("TestValidator.linked.cs"), "Expected TestValidator.IsValid to be in TestValidator.linked.cs");
fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateMethodKey(typeof(TestEntity).GetMethod("ServerAndClientMethod")));
Assert.IsNotNull(fileIds, "Expected TestEntity.ServerAndClientMethod to have non-null file ID's because it is shared");
Assert.AreEqual(1, fileIds.Length, "Expected TestEntity.ServerAndClientMethod to be found in exactly one file");
Assert.IsTrue(filenameMap[fileIds[0]].Contains("TestEntity.linked.cs"), "Expected TestEntity.ServerAndClientMethod to be in TestEntity.linked.cs");
fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateMethodKey(typeof(TestEntity).GetMethod("ServerMethod")));
Assert.IsNull(fileIds, "Expected TestEntity.ServerMethod to have null file ids");
fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateMethodKey(typeof(TestValidatorServer).GetMethod("IsValid")));
Assert.IsNull(fileIds, "Expected TestValidatorServer.IsValid to have null file ids");
}
}
public void SharedCodeService_Types()
{
string projectPath, outputPath;
TestHelper.GetProjectPaths("STS1", out projectPath, out outputPath);
var clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
var logger = new ConsoleLogger();
using (var scs = CodeGenHelper.CreateSharedCodeService(clientProjectPath, logger))
{
// TestEntity is shared because it is linked
CodeMemberShareKind shareKind = scs.GetTypeShareKind(typeof(TestEntity).AssemblyQualifiedName);
Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestEntity type to be shared by reference");
// TestValidator is shared because it is linked
shareKind = scs.GetTypeShareKind(typeof(TestValidator).AssemblyQualifiedName);
Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestValidator type to be shared by reference");
// SharedClass is shared because it is linked
shareKind = scs.GetTypeShareKind(typeof(SharedClass).AssemblyQualifiedName);
Assert.IsTrue(shareKind == CodeMemberShareKind.SharedBySource, "Expected SharedClass type to be shared in source");
// TestValidatorServer exists only on the server and is not shared
shareKind = scs.GetTypeShareKind(typeof(TestValidatorServer).AssemblyQualifiedName);
Assert.IsTrue(shareKind == CodeMemberShareKind.NotShared, "Expected TestValidatorServer type not to be shared");
// CodelessType exists on both server and client, but lacks all user code necessary
// to determine whether it is shared. Because it compiles into both projects, it should
// be considered shared by finding the type in both assemblies
shareKind = scs.GetTypeShareKind(typeof(CodelessType).AssemblyQualifiedName);
Assert.IsTrue(shareKind == CodeMemberShareKind.SharedByReference, "Expected CodelessType type to be shared in assembly");
}
}
public void SharedSourceFiles_Types()
{
string projectPath = null;
string outputPath = null;
TestHelper.GetProjectPaths("SFT", out projectPath, out outputPath);
string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
List <string> sourceFiles = CodeGenHelper.ClientClassLibSourceFiles(clientProjectPath);
ConsoleLogger logger = new ConsoleLogger();
FilenameMap filenameMap = new FilenameMap();
using (SourceFileLocationService locationService = new SourceFileLocationService(new[] { new PdbSourceFileProviderFactory(/*symbolSearchPath*/ null, logger) }, filenameMap))
{
SharedSourceFiles ssf = new SharedSourceFiles(locationService, filenameMap, sourceFiles);
int[] fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateTypeKey(typeof(TestEntity)));
Assert.IsNotNull(fileIds, "Expected TestEntity to have non-null file ID's because it is shared");
Assert.AreEqual(2, fileIds.Length, "Expected TestEntity to be found in exactly 2 files");
foreach (int i in fileIds)
{
string file = filenameMap[i];
Assert.IsTrue(file.Contains("TestEntity.linked.cs") || file.Contains("TestEntity.reverse.linked.cs"), "Expected exactly these 2 files to be shared");
}
fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateTypeKey(typeof(TestValidator)));
Assert.IsNotNull(fileIds, "Expected TestValidator to have non-null file ID's because it is shared");
Assert.AreEqual(1, fileIds.Length, "Expected TestValidator to be found in exactly one file");
Assert.IsTrue(filenameMap[fileIds[0]].Contains("TestValidator.linked.cs"), "expected this to be the sole shared file for TestValidator");
fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateTypeKey(typeof(TestValidatorServer)));
Assert.IsNull(fileIds, "Expected TestValidatorServer to have no shared file ids");
}
}
public void SharedCodeService_Methods()
{
string projectPath, outputPath;
TestHelper.GetProjectPaths("STS4", out projectPath, out outputPath);
var clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
var logger = new ConsoleLogger();
using (var scs = CodeGenHelper.CreateSharedCodeService(clientProjectPath, logger))
{
CodeMemberShareKind shareKind = scs.GetMethodShareKind(typeof(TestValidator).AssemblyQualifiedName, "IsValid", new string[] { typeof(TestEntity).AssemblyQualifiedName, typeof(ValidationContext).AssemblyQualifiedName });
Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestValidator.IsValid to be shared by reference");
shareKind = scs.GetMethodShareKind(typeof(TestEntity).AssemblyQualifiedName, "ServerAndClientMethod", new string[0]);
Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestValidator.ServerAndClientMethod to be shared by reference");
shareKind = scs.GetMethodShareKind(typeof(TestEntity).AssemblyQualifiedName, "ServerMethod", new string[0]);
Assert.AreEqual(CodeMemberShareKind.NotShared, shareKind, "Expected TestValidator.ServerMethod not to be shared");
shareKind = scs.GetMethodShareKind(typeof(TestValidatorServer).AssemblyQualifiedName, "IsValid", new string[] { typeof(TestEntity).AssemblyQualifiedName, typeof(ValidationContext).AssemblyQualifiedName });
Assert.AreEqual(CodeMemberShareKind.NotShared, shareKind, "Expected TestValidator.IsValid not to be shared");
TestHelper.AssertNoErrorsOrWarnings(logger);
}
}
/// <summary>
/// Creates a new CreateClientFilesTask instance to use to generate code
/// </summary>
/// <param name="relativeTestDir"></param>
/// <param name="includeClientOutputAssembly">if <c>true</c> include clients own output assembly in analysis</param>
/// <returns>A new task instance that can be invoked to do code gen</returns>
public static CreateClientFilesTask CreateClientFilesTaskInstance_CopyClientProjectToOutput(string relativeTestDir, bool includeClientOutputAssembly)
{
string deploymentDir = Path.GetDirectoryName(typeof(CodeGenHelper).Assembly.Location);
string projectPath = null;
string outputPath = null;
TestHelper.GetProjectPaths(relativeTestDir, out projectPath, out outputPath);
Assert.IsTrue(File.Exists(projectPath), "Could not locate " + projectPath + " necessary for test.");
string serverProjectPath = CodeGenHelper.ServerClassLibProjectPath(projectPath);
string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
return(CodeGenHelper.CreateClientFilesTaskInstance_CopyClientProjectToOutput(serverProjectPath, clientProjectPath, includeClientOutputAssembly));
}
public void SharedAssemblies_Matches_MsCorLib()
{
Type[] sharedTypes = new Type[] {
typeof(Int32),
typeof(string),
typeof(Decimal),
};
Type[] nonSharedTypes = new Type[] {
typeof(SerializableAttribute),
typeof(System.Xml.Linq.XElement)
};
MethodBase[] sharedMethods = new MethodBase[] {
typeof(string).GetMethod("CopyTo"),
};
string projectPath, outputPath;
TestHelper.GetProjectPaths("SAT", out projectPath, out outputPath);
string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
List<string> assemblies = CodeGenHelper.ClientClassLibReferences(clientProjectPath, true);
var logger = new ConsoleLogger();
var sa = new SharedAssemblies(assemblies, Enumerable.Empty<string>(), logger);
foreach (Type t in sharedTypes)
{
Type sharedType = sa.GetSharedType(t.AssemblyQualifiedName);
Assert.IsNotNull(sharedType, "Expected type " + t.Name + " to be considered shared.");
}
foreach (MethodBase m in sharedMethods)
{
string[] parameterTypes = m.GetParameters().Select<ParameterInfo, string>(p => p.ParameterType.AssemblyQualifiedName).ToArray();
MethodBase sharedMethod = sa.GetSharedMethod(m.DeclaringType.AssemblyQualifiedName, m.Name, parameterTypes);
Assert.IsNotNull(sharedMethod, "Expected method " + m.DeclaringType.Name + "." + m.Name + " to be considered shared.");
}
foreach (Type t in nonSharedTypes)
{
Type sType = sa.GetSharedType(t.AssemblyQualifiedName);
Assert.IsNull(sType, "Expected type " + t.Name + " to be considered *not* shared.");
}
}
public void SharedCodeService_Properties()
{
string projectPath, outputPath;
TestHelper.GetProjectPaths("STS2", out projectPath, out outputPath);
var clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
var logger = new ConsoleLogger();
using (var scs = CodeGenHelper.CreateSharedCodeService(clientProjectPath, logger))
{
CodeMemberShareKind shareKind = scs.GetPropertyShareKind(typeof(TestEntity).AssemblyQualifiedName, "ServerAndClientValue");
Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestEntity.ServerAndClientValue property to be shared by reference.");
shareKind = scs.GetPropertyShareKind(typeof(TestEntity).AssemblyQualifiedName, "TheValue");
Assert.AreEqual(CodeMemberShareKind.NotShared, shareKind, "Expected TestEntity.TheValue property not to be shared in source.");
}
}
public void SharedCodeService_Ctors()
{
string projectPath = null;
string outputPath = null;
TestHelper.GetProjectPaths("STS5", out projectPath, out outputPath);
string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
ConsoleLogger logger = new ConsoleLogger();
using (SharedCodeService sts = CodeGenHelper.CreateSharedCodeService(clientProjectPath, logger))
{
ConstructorInfo ctor = typeof(TestValidator).GetConstructor(new Type[] { typeof(string) });
Assert.IsNotNull("Failed to find string ctor on TestValidator");
CodeMemberShareKind shareKind = sts.GetMethodShareKind(typeof(TestValidator).AssemblyQualifiedName, ctor.Name, new string[] { typeof(string).AssemblyQualifiedName });
Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestValidator ctor to be shared by reference");
TestHelper.AssertNoErrorsOrWarnings(logger);
}
}
public void PdbReader_Finds_Types_Files()
{
string projectPath = null;
string outputPath = null;
TestHelper.GetProjectPaths("PDB", out projectPath, out outputPath);
string serverProjectPath = CodeGenHelper.ServerClassLibProjectPath(projectPath);
string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
ConsoleLogger logger = new ConsoleLogger();
FilenameMap filenameMap = new FilenameMap();
using (SourceFileLocationService locationService = new SourceFileLocationService(new[] { new PdbSourceFileProviderFactory(/*symbolSearchPath*/ null, logger) }, filenameMap))
{
List <string> files = new List <string>(locationService.GetFilesForType(typeof(TestEntity)));
Assert.AreEqual(4, files.Count);
CodeGenHelper.AssertContainsFiles(files, serverProjectPath, new string[] { "TestEntity.cs", "TestEntity.shared.cs", "TestEntity.linked.cs" });
CodeGenHelper.AssertContainsFiles(files, clientProjectPath, new string[] { "TestEntity.reverse.linked.cs" });
}
}
public void SharedAssemblies_Methods()
{
string projectPath, outputPath;
TestHelper.GetProjectPaths("SAT", out projectPath, out outputPath);
var clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
var assemblies = CodeGenHelper.ClientClassLibReferences(clientProjectPath, true);
var logger = new ConsoleLogger();
var sa = new SharedAssemblies(assemblies, Enumerable.Empty<string>(), logger);
var sharedMethod = sa.GetSharedMethod(typeof(TestValidator).AssemblyQualifiedName, "IsValid", new[] { typeof(TestEntity).AssemblyQualifiedName, typeof(ValidationContext).AssemblyQualifiedName });
Assert.IsNotNull(sharedMethod, "Expected TestValidator.IsValid to be shared");
Assert.IsTrue(sharedMethod.DeclaringType.Assembly.Location.Contains("ClientClassLib"), "Expected to find method in client class lib");
sharedMethod = sa.GetSharedMethod(typeof(TestEntity).AssemblyQualifiedName, "ServerAndClientMethod", new string[0]);
Assert.IsNotNull(sharedMethod, "Expected TestEntity.ServerAndClientMethod to be shared");
Assert.IsTrue(sharedMethod.DeclaringType.Assembly.Location.Contains("ClientClassLib"), "Expected to find method in client class lib");
sharedMethod = sa.GetSharedMethod(typeof(TestValidator).AssemblyQualifiedName, "ServertMethod", new string[0]);
Assert.IsNull(sharedMethod, "Expected TestValidator.ServerMethod not to be shared");
TestHelper.AssertNoErrorsOrWarnings(logger);
}
public void SharedAssemblies_Types()
{
string projectPath = null;
string outputPath = null;
TestHelper.GetProjectPaths("SAT", out projectPath, out outputPath);
string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath);
List<string> assemblies = CodeGenHelper.ClientClassLibReferences(clientProjectPath, true);
var logger = new ConsoleLogger();
var sa = new SharedAssemblies(assemblies, Enumerable.Empty<string>(), logger);
Type sharedType = sa.GetSharedType(typeof(TestEntity).AssemblyQualifiedName);
Assert.IsNotNull(sharedType, "Expected TestEntity type to be shared");
Assert.IsTrue(sharedType.Assembly.Location.Contains("ClientClassLib"), "Expected to find type in client class lib");
sharedType = sa.GetSharedType(typeof(TestValidator).AssemblyQualifiedName);
Assert.IsNotNull(sharedType, "Expected TestValidator type to be shared");
Assert.IsTrue(sharedType.Assembly.Location.Contains("ClientClassLib"), "Expected to find type in client class lib");
sharedType = sa.GetSharedType(typeof(TestValidatorServer).AssemblyQualifiedName);
Assert.IsNull(sharedType, "Expected TestValidatorServer type not to be shared");
TestHelper.AssertNoErrorsOrWarnings(logger);
}
