public ImmutableArray <PartitionInfo> Schedule(string assemblyPath, bool force = false)
{
if (_options.Sequential)
{
return(ImmutableArray.Create(new PartitionInfo(assemblyPath)));
}
var typeInfoList = GetTypeInfoList(assemblyPath);
AssemblyInfoBuilder.Build(assemblyPath, _methodLimit, typeInfoList, out var partitionList);
// If the scheduling didn't actually produce multiple partition then send back an unpartitioned
// representation.
if (partitionList.Length == 1 && !force)
{
Logger.Log($"Assembly schedule produced a single partition {assemblyPath}");
return(ImmutableArray.Create(new PartitionInfo(assemblyPath)));
}
Logger.Log($"Assembly Schedule: {Path.GetFileName(assemblyPath)}");
foreach (var partition in partitionList)
{
var methodCount = partition.TypeInfoList.Sum(x => x.MethodCount);
var delta = methodCount - _methodLimit;
Logger.Log($" Partition: {partition.AssemblyPartitionId} method count {methodCount} delta {delta}");
foreach (var typeInfo in partition.TypeInfoList)
{
Logger.Log($" {typeInfo.FullName} {typeInfo.MethodCount}");
}
}
return(partitionList);
}
public IEnumerable <AssemblyInfo> Schedule(string assemblyPath, bool force = false)
{
if (_options.Sequential)
{
return(new[] { CreateAssemblyInfo(assemblyPath) });
}
var typeInfoList = GetTypeInfoList(assemblyPath);
var assemblyInfoList = new List <AssemblyInfo>();
var partitionList = new List <Partition>();
AssemblyInfoBuilder.Build(assemblyPath, _methodLimit, _options.IncludeHtml, typeInfoList, out partitionList, out assemblyInfoList);
// If the scheduling didn't actually produce multiple partition then send back an unpartitioned
// representation.
if (assemblyInfoList.Count == 1 && !force)
{
Logger.Log($"Assembly schedule produced a single partition {assemblyPath}");
return(new[] { CreateAssemblyInfo(assemblyPath) });
}
Logger.Log($"Assembly Schedule: {Path.GetFileName(assemblyPath)}");
foreach (var partition in partitionList)
{
var methodCount = partition.TypeInfoList.Sum(x => x.MethodCount);
var delta = methodCount - _methodLimit;
Logger.Log($" Partition: {partition.Id} method count {methodCount} delta {delta}");
foreach (var typeInfo in partition.TypeInfoList)
{
Logger.Log($" {typeInfo.FullName} {typeInfo.MethodCount}");
}
}
return(assemblyInfoList);
}
public IEnumerable <AssemblyInfo> Schedule(string assemblyPath, bool force = false)
{
var typeInfoList = GetTypeInfoList(assemblyPath);
var assemblyInfoList = new List <AssemblyInfo>();
var chunkList = new List <Chunk>();
AssemblyInfoBuilder.Build(assemblyPath, _methodLimit, _options.UseHtml, typeInfoList, out chunkList, out assemblyInfoList);
// If the scheduling didn't actually produce multiple chunks then send back an unchunked
// representation.
if (assemblyInfoList.Count == 1 && !force)
{
Logger.Log($"Assembly schedule produced a single chunk {assemblyPath}");
return(new[] { CreateAssemblyInfo(assemblyPath) });
}
Logger.Log($"Assembly Schedule: {Path.GetFileName(assemblyPath)}");
foreach (var chunk in chunkList)
{
var methodCount = chunk.TypeInfoList.Sum(x => x.MethodCount);
var delta = methodCount - _methodLimit;
Logger.Log($" Chunk: {chunk.Id} method count {methodCount} delta {delta}");
foreach (var typeInfo in chunk.TypeInfoList)
{
Logger.Log($" {typeInfo.FullName} {typeInfo.MethodCount}");
}
}
return(assemblyInfoList);
}
public void WithAssemblyInformationalVersion_WithVersion_BuildsCorrectAssemblyInfo()
{
var builder = new AssemblyInfoBuilder(new CSharpCodeProvider());
builder.WithAssemblyInformationalVersion("4.3.2.1 Beta 4");
var assemblyInfo = builder.Build();
Assert.Contains("[assembly: System.Reflection.AssemblyInformationalVersionAttribute(\"4.3.2.1 Beta 4\")]", assemblyInfo);
}
public void WithAssemblyInformationalVersion_WithSpecialChars_BuildsCorrectAssemblyInfo()
{
var builder = new AssemblyInfoBuilder(new CSharpCodeProvider());
builder.WithAssemblyInformationalVersion("4.3.2.1 code-named \"Maverick\"");
var assemblyInfo = builder.Build();
Assert.Contains("[assembly: System.Reflection.AssemblyInformationalVersionAttribute(\"4.3.2.1 code-named \\\"Maverick\\\"\")]", assemblyInfo);
}
internal static void Build(string assemblyPath, int methodLimit, bool useHtml, List <TypeInfo> typeInfoList, out List <Chunk> chunkList, out List <AssemblyInfo> assemblyInfoList)
{
var builder = new AssemblyInfoBuilder(assemblyPath, methodLimit, useHtml);
builder.Build(typeInfoList);
chunkList = builder._chunkList;
assemblyInfoList = builder._assemblyInfoList;
}
internal static void Build(string assemblyPath, int methodLimit, List <TypeInfo> typeInfoList, out List <Partition> partitionList, out List <AssemblyPartitionInfo> assemblyInfoList)
{
var hasEventListenerGuard = typeInfoList.Any(x => x.FullName == EventListenerGuardFullName);
var builder = new AssemblyInfoBuilder(assemblyPath, methodLimit, hasEventListenerGuard);
builder.Build(typeInfoList);
partitionList = builder._partitionList;
assemblyInfoList = builder._assemblyInfoList;
}
public void WithAssemblyInformationalVersion_CanBeCalledMoreThanOnce()
{
var builder = new AssemblyInfoBuilder(new CSharpCodeProvider());
builder
.WithAssemblyInformationalVersion("4.3.2.1 code-named \"Maverick\"")
.WithAssemblyInformationalVersion("3.0 code-named \"Maverick\"");
var assemblyInfo = builder.Build();
Assert.Contains("[assembly: System.Reflection.AssemblyInformationalVersionAttribute(\"3.0 code-named \\\"Maverick\\\"\")]", assemblyInfo);
}
public void WithAssemblyFileVersion_CanBeCalledMoreThanOnce()
{
var builder = new AssemblyInfoBuilder(new CSharpCodeProvider());
builder
.WithAssemblyFileVersion(new Version(4, 3, 2, 1))
.WithAssemblyFileVersion(new Version(1, 2, 3, 4));
var assemblyInfo = builder.Build();
Assert.Contains("[assembly: System.Reflection.AssemblyFileVersionAttribute(\"1.2.3.4\")]", assemblyInfo);
}
public IEnumerable <AssemblyPartitionInfo> Schedule(string assemblyPath, bool force = false)
{
var typeInfoList = GetTypeInfoList(assemblyPath);
var assemblyInfoList = new List <AssemblyPartitionInfo>();
var partitionList = new List <Partition>();
AssemblyInfoBuilder.Build(assemblyPath, _methodLimit, typeInfoList, out partitionList, out assemblyInfoList);
// If the scheduling didn't actually produce multiple partition then send back an unpartitioned
// representation.
if (assemblyInfoList.Count == 1 && !force)
{
// Logger.Log($"Assembly schedule produced a single partition {assemblyPath}");
return(new[] { CreateAssemblyInfo(assemblyPath) });
}
return(assemblyInfoList);
}
internal static void Build(string assemblyPath, int methodLimit, bool useHtml, List<TypeInfo> typeInfoList, out List<Chunk> chunkList, out List<AssemblyInfo> assemblyInfoList)
{
var builder = new AssemblyInfoBuilder(assemblyPath, methodLimit, useHtml);
builder.Build(typeInfoList);
chunkList = builder._chunkList;
assemblyInfoList = builder._assemblyInfoList;
}
public void WithCLSCompliant_WithTrue_BuildsCorrectAssemblyInfo()
{
var builder = new AssemblyInfoBuilder(new CSharpCodeProvider());
builder.WithCLSCompliant(true);
var assemblyInfo = builder.Build();
Assert.Contains("[assembly: System.CLSCompliantAttribute(true)]", assemblyInfo);
}
public void WithCLSCompliant_CanBeCalledMoreThanOnce()
{
var builder = new AssemblyInfoBuilder(new CSharpCodeProvider());
builder
.WithCLSCompliant(true)
.WithCLSCompliant(false);
var assemblyInfo = builder.Build();
Assert.Contains("[assembly: System.CLSCompliantAttribute(false)]", assemblyInfo);
}
internal static void Build(string assemblyPath, int methodLimit, bool useHtml, List<TypeInfo> typeInfoList, out List<Partition> partitionList, out List<AssemblyInfo> assemblyInfoList)
{
var hasEventListenerGuard = typeInfoList.Any(x => x.FullName == EventListenerGuardFullName);
var builder = new AssemblyInfoBuilder(assemblyPath, methodLimit, useHtml, hasEventListenerGuard);
builder.Build(typeInfoList);
partitionList = builder._partitionList;
assemblyInfoList = builder._assemblyInfoList;
}
