private static ClassDeclarationSyntax CreateClass(
ClassDeclarationSyntax parentClass,
ConstructorDeclarationSyntax constructor)
{
ObjectCreationExpressionSyntax CreateMoq(TypeSyntax moqType) =>
EGH.CreateObject(
moqType,
SF.Argument(
EGH.MemberAccess(
GH.Identifier("MockBehavior"),
GH.Identifier("Strict"))));
var mi = new MethodInspector(constructor);
var recordBuilder = new RecordBuilder($"{mi.Name}Test")
.AddModifiers(Modifiers.Public);
foreach (var p in mi.Parameters)
{
var mockedType = GetMockedType(p.Type);
var moqType = GH.GenericName("Mock", mockedType);
recordBuilder.AddField(moqType, MockName(p.Name), CreateMoq(moqType));
}
recordBuilder.AddMethod(GenerateCreateSut(parentClass, mi));
return(recordBuilder.Build());
}
private static ClassDeclarationSyntax CreateClass(
SemanticModel semanticModel,
MethodDeclarationSyntax method)
{
var mi = new MethodInspector(method);
var semanticQuery = mi.CreateSemanticQuery(semanticModel);
var isTaskReturn = SymbolSemanticQuery.IsTask(
semanticQuery.GetReturnType().Symbol);
var parameters = mi.Parameters.Select(par => par.Type).ToList();
var recordBuilder = new RecordBuilder($"{mi.Name}Command")
.AddModifiers(Modifiers.Public)
.AddProperties(
mi.Parameters
.Select(p => (p.Type, p.Name)).ToArray());
if (isTaskReturn.IsTask())
{
AddTaskUtilities(recordBuilder, Types.Bool);
}
else if (isTaskReturn.IsTypedTask(out var typeSymbol))
{
AddTaskUtilities(
recordBuilder,
GH.Identifier(SymbolSemanticQuery.GetName(typeSymbol)));
}
return(recordBuilder.Build());
}
private void createRecordStructureXmlToolStripMenuItem_Click(object sender, EventArgs e)
{
var p = GetPluginFromNode(PluginTree.SelectedRecord);
var builder = new RecordBuilder();
builder.FormLookup = GetRecordByID;
builder.StringLookup = LookupFormStrings;
builder.CancelAction = () => { return(backgroundWorker1.CancellationPending); };
builder.UpdateProgressAction = UpdateBackgroundProgress;
StartBackgroundWork(
() => { builder.Start(p); },
() =>
{
if (!IsBackroundProcessCanceled())
{
using (var dlg = new SaveFileDialog())
{
dlg.InitialDirectory = Path.GetTempPath();
dlg.FileName = "RecordStructure.xml";
dlg.OverwritePrompt = false;
if (dlg.ShowDialog() == DialogResult.OK)
{
var xs = new XmlSerializer(typeof(Records));
using (StreamWriter fs = File.CreateText(dlg.FileName))
{
xs.Serialize(fs, builder.Complete());
}
}
}
}
}
);
}
/// <summary>
/// Streams all records of a CSV file using the specified delimiter.
/// </summary>
/// <param name="fileInfo">The CSV file to read.</param>
/// <param name="readHeader"><c>true</c> if the first row contains the header.</param>
/// <param name="delimiter">The delimiter for the values.</param>
/// <returns>The records of this file.</returns>
public IEnumerable <IReferenceRecord> StreamFile(FileInfo fileInfo, bool readHeader, char delimiter)
{
var header = new List <string>();
using (var reader = new StreamReader(fileInfo.OpenRead()))
{
string line;
const int ChunkSize = 1000000;
while (null != (line = reader.ReadLine()))
{
var splittedLine = line.Split(delimiter);
if (!header.Any())
{
// Read the header
if (readHeader)
{
foreach (var headerValue in splittedLine)
{
header.Add(headerValue);
}
continue;
}
else
{
for (var index = 0; index < splittedLine.Length; index++)
{
header.Add(string.Format(@"FIELD{0}", index + 1));
}
}
}
if (header.Count == splittedLine.Length)
{
// Read the values
IReferenceRecord record = new ReferenceRecord();
for (var index = 0; index < header.Count; index++)
{
var key = header[index];
var value = splittedLine[index];
if (null != ValueFactory)
{
value = ValueFactory.CreateValue(value);
}
if (null != RecordBuilder)
{
record = RecordBuilder.BuildRecord(record, key, value);
}
else if (!record.Properties.ContainsKey(key))
{
record.Properties.Add(key, value);
}
}
// Stream the record
yield return(record);
}
}
}
}
public Record Initialize(SpoolSpace Memory)
{
RecordBuilder rb = new RecordBuilder();
foreach (Expression x in this._Values)
{
rb.Add(x.Initialize(Memory));
}
return(rb.ToRecord());
}
public Record ToRecord(SpoolSpace Memory)
{
RecordBuilder rb = new RecordBuilder();
foreach (Expression sx in this._Values.Values)
{
rb.Add(sx.Evaluate(Memory));
}
return(rb.ToRecord());
}
public Record AggRender(Record Work)
{
RecordBuilder rb = new RecordBuilder();
for (int i = 0; i < Work.Count; i++)
{
rb.Add(this._Values[i].AggRender(Work[i]));
}
return(rb.ToRecord());
}
public Record Accumulate(SpoolSpace Memory, Record Work)
{
RecordBuilder rb = new RecordBuilder();
for (int i = 0; i < this._Values.Count; i++)
{
rb.Add(this._Values[i].Accumulate(Memory, Work[i]));
}
return(rb.ToRecord());
}
public void ToArrayTest()
{
var rb = new RecordBuilder();
var array = rb.ToArray();
Assert.AreEqual( 0, array.Length );
rb.Add( "1" );
array = rb.ToArray();
Assert.AreEqual( 1, array.Length );
}
public void ClearTest()
{
var rb = new RecordBuilder( 1 );
rb.Add( "1" );
rb.Add( "2" );
rb.Clear();
var array = rb.ToArray();
Assert.AreEqual( 0, rb.Length );
Assert.AreEqual( 2, rb.Capacity );
Assert.AreEqual( 0, array.Length );
}
public void ToArrayTest()
{
var rb = new RecordBuilder();
var array = rb.ToArray();
Assert.AreEqual(0, array.Length);
rb.Add("1");
array = rb.ToArray();
Assert.AreEqual(1, array.Length);
}
public static SynthRecord CreateRecord(
string username,
uint logonType)
{
using (var rb = new RecordBuilder(ProviderId, EventId, Version))
{
rb.AddUnicodeString(TargetUserName, username);
rb.AddValue(LogonType, logonType);
return(rb.PackIncomplete());
}
}
public void ClearTest()
{
var rb = new RecordBuilder(1);
rb.Add("1");
rb.Add("2");
rb.Clear();
var array = rb.ToArray();
Assert.AreEqual(0, rb.Length);
Assert.AreEqual(2, rb.Capacity);
Assert.AreEqual(0, array.Length);
}
public static SynthRecord CreateRecord(
string userData,
string contextInfo,
string payload)
{
using (var rb = new RecordBuilder(ProviderId, EventId, Version))
{
rb.AddUnicodeString(UserData, userData);
rb.AddUnicodeString(ContextInfo, contextInfo);
rb.AddUnicodeString(Payload, payload);
return(rb.Pack());
}
}
public static SynthRecord CreateRecord(
string url,
string verb,
uint status)
{
using (var rb = new RecordBuilder(ProviderId, EventId, Version))
{
rb.AddAnsiString(URL, url);
rb.AddAnsiString(Verb, verb);
rb.AddValue(Status, status);
return(rb.PackIncomplete());
}
}
/// <summary>
///
/// </summary>
/// <param name="Value"></param>
/// <param name="Columns"></param>
/// <param name="Delim"></param>
/// <param name="Escape"></param>
/// <returns></returns>
public static Record Parse(string Value, Schema Columns, char Delim, char Escape)
{
string[] t = Util.StringUtil.Split(Value, Delim, Escape);
if (t.Length != Columns.Count)
{
throw new Exception();
}
RecordBuilder rb = new RecordBuilder();
for (int i = 0; i < t.Length; i++)
{
rb.Add(Parse(t[i], Columns.ColumnAffinity(i)));
}
return(rb.ToRecord());
}
public static SynthRecord CreateRecord(
uint processId,
string fileName)
{
using (var rb = new RecordBuilder(ProviderId, EventId, Version, OpCode))
{
// NOTE: kernel events MUST have this flag set
rb.Header.Flags = (ushort)EventHeaderFlags.TRACE_MESSAGE;
rb.AddValue(ProcessId, processId);
rb.AddUnicodeString(FileName, fileName);
return(rb.PackIncomplete());
}
}
public void ResizeTest()
{
var rb = new RecordBuilder(2);
rb.Add("1");
Assert.AreEqual(1, rb.Length);
Assert.AreEqual(2, rb.Capacity);
rb.Add("2");
Assert.AreEqual(2, rb.Length);
Assert.AreEqual(2, rb.Capacity);
rb.Add("3");
Assert.AreEqual(3, rb.Length);
Assert.AreEqual(4, rb.Capacity);
}
public void ResizeTest()
{
var rb = new RecordBuilder( 2 );
rb.Add( "1" );
Assert.AreEqual( 1, rb.Length );
Assert.AreEqual( 2, rb.Capacity );
rb.Add( "2" );
Assert.AreEqual( 2, rb.Length );
Assert.AreEqual( 2, rb.Capacity );
rb.Add( "3" );
Assert.AreEqual( 3, rb.Length );
Assert.AreEqual( 4, rb.Capacity );
}
private static void AddTaskUtilities(
RecordBuilder recordBuilder,
TypeSyntax tcsType)
{
var tcs = GeneratorHelper.GenericName(
"TaskCompletionSource",
tcsType);
var initializer = ExpressionGenerationHelper.CreateObject(tcs);
recordBuilder.AddField(tcs, "result", initializer);
var resolveMethod = new MethodBuilder(GH.IdentifierToken("Resolve"))
.Modifiers(Modifiers.Public)
.AddParameter(tcsType, GH.IdentifierToken("value"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetResult"),
SF.Argument(GH.Identifier("value")))
.Build())
.Build();
var cancelMethod = new MethodBuilder(GH.IdentifierToken("Cancel"))
.Modifiers(Modifiers.Public)
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetCanceled"))
.Build())
.Build();
var rejectMethod = new MethodBuilder(GH.IdentifierToken("Reject"))
.Modifiers(Modifiers.Public)
.AddParameter(GH.Identifier("Exception"), GH.IdentifierToken("exc"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetException"),
SF.Argument(GH.Identifier("exc")))
.Build())
.Build();
recordBuilder.AddMethod(resolveMethod);
recordBuilder.AddMethod(cancelMethod);
recordBuilder.AddMethod(rejectMethod);
}
internal Record ToAggShellRecord(SpoolSpace Memory)
{
RecordBuilder rb = new RecordBuilder();
foreach (Expression x in this._Values.Values)
{
if (x.IsAggregate)
{
rb.Add(x.Initialize(Memory));
}
else
{
rb.Add(x.Evaluate(Memory));
}
}
return(rb.ToRecord());
}
// Records //
public static Record ToRecord(string Text, Schema Columns, char[] Delims, char Escape)
{
// SplitUpper the data //
string[] t = StringUtil.Split(Text, Delims, Escape, false);
// Check the length //
if (t.Length != Columns.Count)
{
throw new ArgumentException(string.Format("BString has {0} fields, but schema has {1} fields", t.Length, Columns.Count));
}
// Build the record //
RecordBuilder rb = new RecordBuilder();
for (int i = 0; i < t.Length; i++)
{
rb.Add(CellParser.Parse(t[i], Columns.ColumnAffinity(i)));
}
return(rb.ToRecord());
}
public void Record_Builder()
{
var builder = new RecordBuilder();
builder.Aliases.AddCreate("Employees", "Emp");
builder.Aliases.AddCreate("Countries", "Ctry");
dynamic b = builder;
b.Emp.Id = "007";
b.Emp.FirstName = "James";
b.LastName = "Bond";
b.Ctry.Id = "uk";
IRecord record = builder.Create();
var str = record.ToString();
Assert.AreEqual(
"[Employees.Id = '007', Employees.FirstName = 'James', .LastName = 'Bond', Countries.Id = 'uk']",
str);
}
public void SetsDefaultCapacityInDefaultConstructorTest()
{
var rb = new RecordBuilder();
Assert.AreEqual( 16, rb.Capacity );
}
private void InitializeDependencis()
{
recordBuilder = new RecordBuilder();
databaseCreator = new DatabaseCreator();
serviceSender = new ServiceSender();
}
private void createRecordStructureXmlToolStripMenuItem_Click(object sender, EventArgs e)
{
var p = this.GetPluginFromNode(this.PluginTree.SelectedRecord);
var builder = new RecordBuilder();
builder.FormLookup = this.GetRecordByID;
builder.StringLookup = this.LookupFormStrings;
builder.CancelAction = () => { return this.backgroundWorker1.CancellationPending; };
builder.UpdateProgressAction = this.UpdateBackgroundProgress;
this.StartBackgroundWork(
() => builder.Start(p),
() =>
{
if (!this.IsBackroundProcessCanceled())
{
using (var dlg = new SaveFileDialog())
{
//dlg.InitialDirectory = Path.GetTempPath();
dlg.FileName = "RecordStructure.xml";
dlg.OverwritePrompt = false;
if (dlg.ShowDialog() == DialogResult.OK)
{
var xs = new XmlSerializer(typeof (Records));
using (StreamWriter fs = File.CreateText(dlg.FileName))
{
xs.Serialize(fs, builder.Complete());
}
}
}
}
});
}
private void mergeRecordsXMLToolStripMenuItem_Click(object sender, EventArgs e)
{
Records baseRecords;
Records updateRecords;
var xs = new XmlSerializer(typeof(Records));
using (var dlg = new OpenFileDialog())
{
dlg.Title = "Select Base Record Structure";
dlg.InitialDirectory = Options.Value.SettingsDirectory;
dlg.FileName = "RecordStructure.xml";
if (dlg.ShowDialog(this) != DialogResult.OK)
{
return;
}
using (var fs = File.OpenRead(dlg.FileName))
{
baseRecords = xs.Deserialize(fs) as Records;
}
}
using (var dlg = new OpenFileDialog())
{
dlg.Title = "Select Record Structure XML To Merge";
dlg.InitialDirectory = Options.Value.SettingsDirectory;
//dlg.InitialDirectory = Path.GetTempPath();
dlg.FileName = "RecordStructure.xml";
if (dlg.ShowDialog(this) != DialogResult.OK)
{
return;
}
using (var fs = File.OpenRead(dlg.FileName))
{
updateRecords = xs.Deserialize(fs) as Records;
}
}
if (updateRecords != null && baseRecords != null)
{
var builder = new RecordBuilder();
builder.MergeRecords(baseRecords.Items.OfType<RecordsRecord>(),
updateRecords.Items.OfType<RecordsRecord>());
using (var dlg = new SaveFileDialog())
{
dlg.Title = "Select Record Structure To Save";
dlg.InitialDirectory = Options.Value.SettingsDirectory;
//dlg.InitialDirectory = Path.GetTempPath();
dlg.FileName = "RecordStructure.xml";
dlg.OverwritePrompt = false;
if (dlg.ShowDialog(this) == DialogResult.OK)
{
using (var fs = File.CreateText(dlg.FileName))
{
xs.Serialize(fs, updateRecords);
}
}
}
}
}
private void mergeRecordsXMLToolStripMenuItem_Click(object sender, EventArgs e)
{
Records baseRecords;
Records updateRecords;
var xs = new XmlSerializer(typeof(Records));
using (var dlg = new OpenFileDialog())
{
dlg.Title = "Select Base Record Structure";
dlg.InitialDirectory = Options.Value.SettingsDirectory;
dlg.FileName = "RecordStructure.xml";
if (dlg.ShowDialog(this) != DialogResult.OK)
{
return;
}
using (var fs = File.OpenRead(dlg.FileName))
{
baseRecords = xs.Deserialize(fs) as Records;
}
}
using (var dlg = new OpenFileDialog())
{
dlg.Title = "Select Record Structure XML To Merge";
dlg.InitialDirectory = Options.Value.SettingsDirectory;
//dlg.InitialDirectory = Path.GetTempPath();
dlg.FileName = "RecordStructure.xml";
if (dlg.ShowDialog(this) != DialogResult.OK)
{
return;
}
using (var fs = File.OpenRead(dlg.FileName))
{
updateRecords = xs.Deserialize(fs) as Records;
}
}
if (updateRecords != null && baseRecords != null)
{
var builder = new RecordBuilder();
builder.MergeRecords(baseRecords.Items.OfType <RecordsRecord>(),
updateRecords.Items.OfType <RecordsRecord>());
using (var dlg = new SaveFileDialog())
{
dlg.Title = "Select Record Structure To Save";
dlg.InitialDirectory = Options.Value.SettingsDirectory;
//dlg.InitialDirectory = Path.GetTempPath();
dlg.FileName = "RecordStructure.xml";
dlg.OverwritePrompt = false;
if (dlg.ShowDialog(this) == DialogResult.OK)
{
using (var fs = File.CreateText(dlg.FileName))
{
xs.Serialize(fs, updateRecords);
}
}
}
}
}
public void Record_Builder()
{
var builder = new RecordBuilder();
builder.Aliases.AddCreate("Employees", "Emp");
builder.Aliases.AddCreate("Countries", "Ctry");
dynamic b = builder;
b.Emp.Id = "007";
b.Emp.FirstName = "James";
b.LastName = "Bond";
b.Ctry.Id = "uk";
IRecord record = builder.Create();
var str = record.ToString();
Assert.AreEqual(
"[Employees.Id = '007', Employees.FirstName = 'James', .LastName = 'Bond', Countries.Id = 'uk']",
str);
}
public void SetsCapacityWhenGivenInConstructorTest()
{
var rb = new RecordBuilder(1);
Assert.AreEqual(1, rb.Capacity);
}
public void SetsDefaultCapacityWhenZeroCapacityIsGivenInConstructorTest()
{
var rb = new RecordBuilder(0);
Assert.AreEqual(16, rb.Capacity);
}
public void SetsDefaultCapacityInDefaultConstructorTest()
{
var rb = new RecordBuilder();
Assert.AreEqual(16, rb.Capacity);
}
/// <summary>
/// Reads a CSV file using the specified delimiter.
/// </summary>
/// <param name="fileInfo">The CSV file to read.</param>
/// <param name="readHeader"><c>true</c> if the first row contains the header.</param>
/// <param name="delimiter">The delimiter for the values.</param>
/// <returns>A reference dataset.</returns>
public ReferenceDataset ReadFile(FileInfo fileInfo, bool readHeader, char delimiter)
{
var dataset = new ReferenceDataset();
var header = new List <string>();
using (var reader = new StreamReader(fileInfo.OpenRead()))
{
string line;
const int ChunkSize = 1000000;
while (null != (line = reader.ReadLine()))
{
var splittedLine = line.Split(delimiter);
if (!header.Any())
{
// Read the header
if (readHeader)
{
foreach (var headerValue in splittedLine)
{
header.Add(headerValue);
}
continue;
}
else
{
for (var index = 0; index < splittedLine.Length; index++)
{
header.Add(string.Format(@"FIELD{0}", index + 1));
}
}
}
if (header.Count == splittedLine.Length)
{
try
{
// Read the values
IReferenceRecord record = new ReferenceRecord();
for (var index = 0; index < header.Count; index++)
{
var key = header[index];
var value = splittedLine[index];
if (null != ValueFactory)
{
value = ValueFactory.CreateValue(value);
}
if (null != RecordBuilder)
{
record = RecordBuilder.BuildRecord(record, key, value);
}
else if (!record.Properties.ContainsKey(key))
{
record.Properties.Add(key, value);
}
}
// Add the record
dataset.Records.Add(record);
if (0 == dataset.Records.Count % ChunkSize)
{
_logger.Info(@"{0} records created.", dataset.Records.Count);
}
}
catch (Exception ex)
{
_logger.Error(@"Error during record creation! '{0}'", ex.Message);
}
}
}
}
return(dataset);
}
public void SetsCapacityWhenGivenInConstructorTest()
{
var rb = new RecordBuilder( 1 );
Assert.AreEqual( 1, rb.Capacity );
}
public async Task Test2()
{
// Arrange
var text = @"
using System;
using System.Threading.Tasks;
namespace RefactorClasses.Analysis.Test
{
[StateMachine(ContextType = typeof(ContextBase), StateType = typeof(StateBase), TriggerType = (typeof(TriggerBase)))]
public class StateMachineImpl
{
public void DoSomething(
int a,
Test1 testClass, string fdeee)
{
}
public async Task<int> TaskMethodReturningSomething(int a, float b)
{
return 10;
}
public System.Threading.Tasks.Task AsyncOperationsSupport(int a, float b)
{
return Task.CompletedTask;
}
public async Task TaskMethod(int a, float b)
{
return;
}
public async Task TaskMethodWithArrays(int[] a, float[] b)
{
return;
}
public async Task TaskMethodWithTuples((int, float) a, float[] b)
{
return;
}
private void PrintSomething() {}
}
public class TriggerBase { }
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
public sealed class StateMachineAttribute : Attribute
{
public Type StateType { get; set; }
public Type TriggerType { get; set; }
public Type ContextType { get; set; }
}
}";
var tree = CSharpSyntaxTree.ParseText(text);
var compilation = TestHelpers.CreateCompilation(tree);
var semanticModel = compilation.GetSemanticModel(tree);
var classDeclaration = TestHelpers.FindFirstClassDeclaration(await tree.GetRootAsync());
var classInspector = new ClassInspector(classDeclaration);
var semanticInspector = classInspector.CreateSemanticQuery(semanticModel);
bool foundAttribute = semanticInspector.TryFindFirstAttributeMatching(
"StateMachineAttribute", out var atData);
var triggerType = atData
?.NamedArguments
.FirstOrDefault(kvp => kvp.Key.Equals("TriggerType"));
if (triggerType == null)
{
return;
}
var methods = classInspector.FindMatchingMethods(
mi => mi.Check(m => m.IsPublic() && !m.IsStatic()).Passed);
foreach (var method in methods)
{
var msq = method.CreateSemanticQuery(semanticModel);
var returnType = msq.GetReturnType();
var isTaskReturn = IsTask(returnType.Symbol);
var parameters = method.Parameters.Select(par => par.Type).ToList();
// TODO: will throw if array
var triggerTypeName = triggerType.Value.Value.Value as INamedTypeSymbol;
if (triggerTypeName == null)
{
return;
}
var recordBuilder = new RecordBuilder(method.Name)
.AddModifiers(Modifiers.Public)
.AddBaseTypes(GeneratorHelper.Identifier(triggerTypeName.Name))
.AddProperties(
method.Parameters
.Select(p => (p.Type, p.Name)).ToArray());
if (isTaskReturn.Value.IsTask())
{
var boolTcs = GeneratorHelper.GenericName(
"TaskCompletionSource",
Types.Bool);
var initializer = ExpressionGenerationHelper.CreateObject(boolTcs);
recordBuilder.AddField(boolTcs, "result", initializer);
var resolveMethod = new MethodBuilder(GH.IdentifierToken("Resolve"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetResult"),
SF.Argument(GH.Identifier("true")))
.Build())
.Build();
var cancelMethod = new MethodBuilder(GH.IdentifierToken("Cancel"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetCanceled"))
.Build())
.Build();
var rejectMethod = new MethodBuilder(GH.IdentifierToken("Cancel"))
.AddParameter(GH.Identifier("Exception"), GH.IdentifierToken("exc"))
.Body(new BodyBuilder()
.AddVoidMemberInvocation(
GH.Identifier("result"),
GH.Identifier("TrySetException"),
SF.Argument(GH.Identifier("exc")))
.Build())
.Build();
recordBuilder.AddMethod(resolveMethod);
recordBuilder.AddMethod(cancelMethod);
recordBuilder.AddMethod(rejectMethod);
int ddddd = 0;
}
else if (isTaskReturn.Value.IsTypedTask(out var taskType))
{
var typedTcs = GeneratorHelper.GenericName(
"TaskCompletionSource",
GeneratorHelper.Identifier(taskType.Name));
var initializer = ExpressionGenerationHelper.CreateObject(typedTcs);
recordBuilder.AddField(typedTcs, "result", initializer);
}
var record = recordBuilder.Build();
// TODO: if task is returned -> generate TaskCompletionSource
// and matching methods
var rs = record.ToString();
int a = 10;
}
// Act
// Assert
IsTaskResult?IsTask(ISymbol symbol)
{
var namedSymbol = symbol as INamedTypeSymbol;
if (namedSymbol == null)
{
return(null);
}
if (namedSymbol.Name == "Task" &&
namedSymbol?.ContainingNamespace?.ToString() == "System.Threading.Tasks")
{
var firstTypeArg = namedSymbol.TypeArguments.FirstOrDefault();
if (firstTypeArg != null)
{
return(IsTaskResult.TypedTask(firstTypeArg));
}
else
{
return(IsTaskResult.Task());
}
}
return(IsTaskResult.NotATask());
}
//var tcs = new TaskCompletionSource<int>();
//tcs.TrySetException()
}
public void SetsDefaultCapacityWhenZeroCapacityIsGivenInConstructorTest()
{
var rb = new RecordBuilder( 0 );
Assert.AreEqual( 16, rb.Capacity );
}
