private ICliMetadataCustomAttribute GetCustomAttribute(_ICliManager identityManager, ICliMetadataCustomAttributeTableRow target, _ICliMetadataBlobEntry entry)
{
uint offset = target.ValueIndex + entry.LengthByteCount;
this.reader.BaseStream.Seek(offset, SeekOrigin.Begin);
return((ICliMetadataCustomAttribute)(entry.Signature = SignatureParser.ParseCustomAttribute(reader, metadataRoot, identityManager, target, (uint)entry.Length)));
}
public void ParseParameters_should_handle_empty_list()
{
var s = new SignatureParser("[]");
s.MoveNext();
Assert.Empty(s.ParseParameters(TokenType.RightBracket));
}
public void ParseQualifiedType_should_handle_basic_name()
{
var t = SignatureParser.ParseQualifiedType("A");
Assert.Equal("A", t.Name);
Assert.Equal("", t.Namespace);
}
public void ParseQualifiedType_should_handle_namespace_nested()
{
var t = SignatureParser.ParseQualifiedType("N.A.B");
Assert.Equal("B", t.Name);
Assert.Equal("N.A", t.Namespace);
}
private void lbInstructions_SelectedIndexChanged(object sender, EventArgs e)
{
lbOverloads.Items.Clear();
lblInstructionName.Text = "Instruction: ";
if (lbInstructions.SelectedIndex != -1)
{
string inst = lbInstructions.SelectedItem.ToString();
if (inst.StartsWith("(INCOMPATIBLE)"))
{
inst = inst.Remove(0, "(INCOMPATIBLE)".Length);
}
FLInstructionCreator c = FindCreator(inst);
string args = c.GetArgumentSignatureForInstruction(inst);
bool ret = SignatureParser.ParseCreatorSig(args, out List <InstructionArgumentSignature> sig);
lblInstructionName.Text = "Instruction: " + inst;
rtbInstructionDescription.Text = c.GetDescriptionForInstruction(inst);
lbOverloads.Items.Clear();
for (int i = 0; i < sig.Count; i++)
{
lbOverloads.Items.Add(sig[i]);
}
}
}
public void ParseQualifiedType_should_extract_implied_generic_nested()
{
var t = SignatureParser.ParseQualifiedType("System.Collections.Generic.Dictionary`2.ValueCollection");
Assert.Equal("ValueCollection", t.Name);
Assert.Equal("Dictionary`2", t.DeclaringType.Name);
Assert.Equal("System.Collections.Generic", t.Namespace);
}
public void ParseQualifiedType_should_handle_nested_types(string text)
{
var t = SignatureParser.ParseQualifiedType(text);
Assert.Equal("B", t.Name);
Assert.Equal("A", t.DeclaringType.Name);
Assert.Equal("N", t.Namespace);
}
public void ParseParameters_should_handle_whitespace(string text)
{
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseParameters(TokenType.RightBracket).ToList();
Assert.Equal(5, data.Count);
}
public void ParseQualifiedName_should_handle_various(string text)
{
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseQualifiedName();
Assert.Equal(text, data);
}
public void ApplyChangesToProcedure(Procedure procedure)
{
var ser = arch.CreateProcedureSerializer(new TypeLibraryLoader(arch, true), "stdapi"); //BUG:Where does convetion come from? Platform?
var sp = new SignatureParser(arch);
sp.Parse(dlg.Signature.Text);
Debug.Assert(sp.IsValid);
procedure.Signature = ser.Deserialize(sp.Signature, procedure.Frame);
}
private void PopulateFields()
{
dlg.ProcedureName.Text = proc.Name.Trim();
if (proc.Signature != null)
{
dlg.Signature.Text = SignatureParser.UnparseSignature(proc.Signature, proc.Name);
PopulateSignatureFields(proc.Signature);
}
}
public void TestDbSignatures(string input, string output)
{
var signatureParser = new SignatureParser(new Scanner());
var name = new StringBuilder();
signatureParser.QuerySignature(input.Replace(Environment.NewLine, " "), name, false);
name.ToString().ToLower().Should().Be(output.ToLower());
}
public async Task SimpleDbTest()
{
// 4 DB spans:
// 1) CREATE TABLE
// the first "new SampleDataDbContext()"
// 2) INSERT for
// dbCtx.Set<SampleData>().Add(new SampleData { Name = simpleDbTestSampleDataName });
// 3) SELECT for
// ```if (dbCtx.Set<SampleData>().Count() != 1)
// 4) SELECT for
// if (dbCtx.Set<SampleData>().First().Name != simpleDbTestSampleDataName)
var pageData = new SampleAppUrlPathData(HomeController.SimpleDbTestPageRelativePath, 200, spansCount: 4);
await SendGetRequestToSampleAppAndVerifyResponse(pageData.Uri, pageData.StatusCode);
await WaitAndCustomVerifyReceivedData(receivedData =>
{
VerifyReceivedDataSharedConstraints(pageData, receivedData);
// See comment for TestsBase.SampleAppUrlPaths.SimpleDbTestPage
var dbStatements = new[] { "CREATE TABLE", "INSERT", "SELECT", "SELECT" };
var transaction = receivedData.Transactions.First();
receivedData.Spans.ForEachIndexed((span, i) =>
{
var signatureParser = new SignatureParser(new Scanner());
var name = new StringBuilder();
signatureParser.QuerySignature(dbStatements[i], name, preparedStatement: false);
span.Name.Should().StartWith(name.ToString());
span.Type.Should().Be(ApiConstants.TypeDb);
span.Subtype.Should().Be(ApiConstants.SubtypeSqLite);
span.Context.Db.Type.Should().Be(Database.TypeSql);
span.Outcome.Should().Be(Outcome.Success);
span.Context.Db.Instance.Should().NotBeNull();
span.Context.Db.Instance.Should().Be(receivedData.Spans.First().Context.Db.Instance);
span.Context.Db.Statement.Should().StartWith(dbStatements[i]);
span.Context.Destination.Should().NotBeNull();
span.TraceId.Should().Be(transaction.TraceId);
span.TransactionId.Should().Be(transaction.Id);
span.ParentId.Should().Be(transaction.Id);
span.ShouldOccurBetween(transaction);
if (i != 0)
{
receivedData.Spans[i - 1].ShouldOccurBefore(span);
}
});
ShouldBeMonotonicInTime(receivedData.Spans);
});
}
public void ParseParameter_should_support_type_without_name(TypeName type)
{
var s = new SignatureParser(type.FullName + ",");
s.MoveNext();
var data = s.ParseParameter();
Assert.Empty(data.Name);
Assert.Equal(type, data.Type);
}
public void ParseParameter_should_support_name_without_type(string text)
{
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseParameter();
Assert.Equal("name", data.Name);
Assert.Equal(null, data.Type);
}
public void ParseParameterTypeOpt_should_handle_assembly_name(string text)
{
var s = new SignatureParser(text);
s.MoveNext();
var t = s.ParseParameterTypeOpt();
Assert.NotNull(t.Assembly);
Assert.Equal("mscorlib", t.Assembly.Name);
}
public void ParseTypeParametersOpt_should_imply_types_not_arguments_when_qualified(string text)
{
var s = new SignatureParser("<" + text + ", U, V>");
s.MoveNext();
var data = s.ParseTypeParametersOpt();
Assert.IsNotInstanceOf(typeof(GenericParameterName), data.Raw[0]);
Assert.Equal(TypeName.Parse(text), data.Raw[0]);
Assert.False(data.CouldBeParameters);
}
public void ParseParameterTypeOpt_should_handle_generics(string text)
{
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseParameterTypeOpt();
Assert.NotNull(data);
Assert.Equal(TypeName.Parse(text), data);
}
public void ParseParameter_should_handle_assembly_qualified_type(string text)
{
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseParameter();
Assert.Equal("x", data.Name);
Assert.Equal("System.Object", data.Type.FullName);
Assert.Equal("mscorlib, Version=2.0", data.Type.Assembly.FullName);
}
public void ParseParameter_should_support_colon_type(TypeName type)
{
string text = ":" + type.FullName + ",";
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseParameter();
Assert.Empty(data.Name);
Assert.Equal(type, data.Type);
}
protected void Signature_TextChanged(object sender, EventArgs e)
{
var parser = new SignatureParser(arch);
parser.Parse(dlg.Signature.Text);
EnableControls(parser.IsValid);
if (parser.IsValid)
{
proc.Signature = parser.Signature;
}
}
public void ParseParameter_should_support_type_space_name(TypeName type)
{
string text = type + " " + "name" + ",";
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseParameter();
Assert.Equal("name", data.Name);
Assert.Equal(type, data.Type);
}
public void ParseDeclaringTypeOpt_should_extract_implied_generic_nested()
{
var s = new SignatureParser("System.Collections.Generic.Dictionary`2.ValueCollection.Method(");
s.MoveNext();
string name;
var data = s.ParseDeclaringTypeOpt(out name);
Assert.Equal("Method", name);
Assert.Equal("System.Collections.Generic.Dictionary`2+ValueCollection", data.FullName);
Assert.Equal(TokenType.LeftParen, s.Type);
}
public void ParseTypeParametersOpt_should_handle_empty_list()
{
var s = new SignatureParser("<>");
s.MoveNext();
var result = s.ParseTypeParametersOpt();
var data = result.Raw;
Assert.HasCount(1, data);
Assert.Null(data[0]);
Assert.True(result.MustBeParameters);
}
public void ParseDeclaringTypeOpt_should_extract_declaring_alternate_nested_format()
{
var s = new SignatureParser("Hello/Other.World");
s.MoveNext();
string name;
var data = s.ParseDeclaringTypeOpt(out name);
Assert.Equal("Hello+Other", data.FullName);
Assert.Equal("World", name);
Assert.Equal(TokenType.EndOfInput, s.Type);
}
public void ParseParameters_should_handle_pointer_parameter(string text)
{
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseParameters(TokenType.RightBracket).ToList();
Assert.Equal(1, data.Count);
Assert.Equal("Int64*", data[0].Type.Name);
Assert.True(data[0].Type.IsPointer);
Assert.Equal(TokenType.RightBracket, s.Type);
}
public void ParseParameterTypeOpt_should_handle_arrays(string text, int dimensions)
{
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseParameterTypeOpt();
Assert.NotNull(data);
Assert.True(data.IsArray);
Assert.Equal(dimensions, ((ArrayTypeName)data).Dimensions.Count);
}
public void ParseParameter_should_support_various_formats(TypeName parameterType, string format)
{
string text = format.Replace("{type}", parameterType.ToString())
.Replace("{name}", "p") + ",";
var s = new SignatureParser(text);
s.MoveNext();
var data = s.ParseParameter();
Assert.Equal("p", data.Name);
Assert.Equal(parameterType, data.Type);
}
public void ParseDeclaringTypeOpt_should_handle_constructors_declaring_type(string text)
{
var s = new SignatureParser(text);
s.MoveNext();
string name;
var data = s.ParseDeclaringTypeOpt(out name);
Assert.Equal("Hello", data.Name);
Assert.Equal(text.Substring(1 + "Hello".Length), name);
Assert.Equal(TokenType.EndOfInput, s.Type);
}
public void ParseDeclaringTypeOpt_should_handle_unqualified_names(string text)
{
var s = new SignatureParser(text);
s.MoveNext();
string name;
var data = s.ParseDeclaringTypeOpt(out name);
Assert.Null(data);
Assert.Equal(text, name);
Assert.Equal(TokenType.EndOfInput, s.Type);
}
protected void Signature_TextChanged(object sender, EventArgs e)
{
var parser = new SignatureParser(arch);
parser.Parse(dlg.Signature.Text);
EnableControls(parser.IsValid);
if (parser.IsValid)
{
proc.Signature = parser.Signature;
}
}
public void ApplyChangesToProcedure(Procedure procedure)
{
var ser = arch.CreateProcedureSerializer(new TypeLibraryLoader(arch, true), "stdapi"); //BUG:Where does convetion come from? Platform?
var sp = new SignatureParser(arch);
sp.Parse(dlg.Signature.Text);
Debug.Assert(sp.IsValid);
procedure.Signature = ser.Deserialize(sp.Signature, procedure.Frame);
}
public void ApplyChangesToProcedure(Program program, Procedure procedure)
{
var ser = program.CreateProcedureSerializer();
var sp = new SignatureParser(arch);
sp.Parse(dlg.Signature.Text);
Debug.Assert(sp.IsValid);
procedure.Signature = ser.Deserialize(sp.Signature, procedure.Frame);
}
