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); }
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); }