public void ParseWithCodeModelWithCreateResourceMethod() { CodeModel codeModel = New <CodeModel>(); codeModel.ApiVersion = "2016-01-01"; Parameter body = New <Parameter>(new { Location = ParameterLocation.Body, Type = New <CompositeType>(), }); CompositeType responseBody = New <CompositeType>(); responseBody.Extensions.Add("x-ms-azure-resource", true); const string url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Mock.Provider/mockResourceNames/{mockResourceName}"; Method method = New <Method>(new { HttpMethod = HttpMethod.Put, ReturnType = new Response(responseBody, null), Url = url, }); method.Add(body); codeModel.Add(method); IDictionary <string, ResourceSchema> schemas = ResourceSchemaParser.Parse(codeModel); Assert.NotNull(schemas); Assert.Equal(1, schemas.Count); ResourceSchema schema = schemas["Mock.Provider"]; Assert.Equal("http://schema.management.azure.com/schemas/2016-01-01/Mock.Provider.json#", schema.Id); Assert.Equal("http://json-schema.org/draft-04/schema#", schema.Schema); Assert.Equal("Mock.Provider", schema.Title); Assert.Equal("Mock Provider Resource Types", schema.Description); Assert.Equal(1, schema.ResourceDefinitions.Count); Assert.Equal("mockResourceNames", schema.ResourceDefinitions.Keys.Single()); Assert.Equal( new JsonSchema() { JsonType = "object", Description = "Mock.Provider/mockResourceNames" } .AddProperty("type", JsonSchema.CreateStringEnum("Mock.Provider/mockResourceNames"), true) .AddProperty("apiVersion", JsonSchema.CreateStringEnum("2016-01-01"), true), schema.ResourceDefinitions["mockResourceNames"]); Assert.NotNull(schema.Definitions); Assert.Equal(0, schema.Definitions.Count); }
public void add_two_integers_should_success() { int num1 = 3; int num2 = 5; int expected = 8; int actual = method.Add(num1, num2); Assert.Equal(expected, actual); }
private void BuildMethodParameters(Method method) { foreach (var swaggerParameter in DeduplicateParameters(_operation.Parameters)) { var parameter = ((ParameterBuilder)swaggerParameter.GetBuilder(_swaggerModeler)).Build(); method.Add(parameter); StringBuilder parameterName = new StringBuilder(parameter.Name); parameterName = CollectionFormatBuilder.OnBuildMethodParameter(method, swaggerParameter, parameterName); if (swaggerParameter.In == ParameterLocation.Header) { method.RequestHeaders[swaggerParameter.Name] = string.Format(CultureInfo.InvariantCulture, "{{{0}}}", parameterName); } } }
private void Push(string methodName) { if (OutputConnection != null && OutputConnection.State == ConnectionState.Closed) { throw new Exception(TopMethod + " - Output Connection is closed"); } if (InputConnection != null && InputConnection.State == ConnectionState.Closed) { throw new Exception(TopMethod + " - Input Connection is closed"); } if (MeasurePerformance) { Method.Add(methodName); // push the stack InfoAspect.Measuring(methodName); Level++; } if (Level != Method.Count + 1) { Pause(); } }
public override void Execute(IList <Token> tokens, ref int i) { var currentToken = tokens[i]; if (literal != null) { //ParserHelper.PushToStack(PrevMember, Method); //var member = ParserHelper.GetMember(literal, DefinedTypes, Method.Locals, TypeBuilder); if (PrevMember is MemberInfo[] members) { PrevMember = members[0]; } switch (PrevMember) { case FieldInfo field: Method.StoreField(field); break; case Local local: Method.StoreLocal(local); break; default: ExceptionManager.ThrowCompiler(ErrorCode.NotPossibleToSetValue, "", currentToken.Line); break; } } if (IsInner) { if (tokens[i + 1].TokenType != TokenType.Operator) { ParserHelper.PushToStack(tokens[i].Value, Method, DefinedTypes, TypeBuilder, AsmBuilder); i++; } else { var left = tokens[i].Value; var right = tokens[i + 2].Value; //todo узнавать, переменная, константа или функция (вроде как сделал) ParserHelper.PushToStack(left, Method, DefinedTypes, TypeBuilder, AsmBuilder); ParserHelper.PushToStack(right, Method, DefinedTypes, TypeBuilder, AsmBuilder); //todo добавить больше операций switch (tokens[i + 1].Value) { case "+": Method.Add(); break; case "-": Method.Subtract(); break; case "*": Method.Multiply(); break; case "/": Method.Divide(); break; } i += 3; } } else { if (currentToken.TokenType == TokenType.Type) { if (tokens[i + 1].TokenType == TokenType.Identifier) { if (!ParserHelper.CheckUnusedLocal(tokens, _methodBodyState.FirstInstructionIndex, tokens[i + 1].Value)) { var type = DefinedTypes[currentToken.Value]; Method.DeclareLocal(type, tokens[i + 1].Value); i++; } } i++; PrevMember = DefinedTypes[currentToken.Value]; } else if (currentToken.Value == "=") //(currentToken.TokenType == TokenType.Operator) { StateStack.Push(new InstructionState(StateStack, DefinedTypes, AsmBuilder, TypeBuilder, Method) { IsInner = true }); literal = tokens[i - 1].Value; i++; return; //ProcessOperator(tokens, ref i); } else if (currentToken.TokenType == TokenType.Identifier) { if (tokens[i + 1].TokenType == TokenType.OpenBrace) { StateStack.Push(new CallMethodState(StateStack, DefinedTypes, AsmBuilder, TypeBuilder, Method)); return; } PrevMember = ParserHelper.GetMember(currentToken.Value, DefinedTypes, Method.Locals, TypeBuilder, AsmBuilder); i++; } else if (currentToken.Value == "ret") { var nextToken = tokens[i + 1]; if (nextToken.TokenType == TokenType.Identifier || nextToken.TokenType == TokenType.Constant) { ParserHelper.PushToStack(nextToken.Value, Method, DefinedTypes, TypeBuilder, AsmBuilder); i++; } Method.Return(); i++; } else if (currentToken.Value == ".") { MemberInfo[] members; if (PrevMember is Type type) { type = DefinedTypes[type.FullName]; members = type.GetMember(tokens[i + 1].Value); } else { members = PrevMember.GetType().GetMember(tokens[i + 1].Value); } if (members.Length == 0) { ExceptionManager.ThrowCompiler(ErrorCode.UnexpectedToken, string.Empty, tokens[i + 1].Line); } var currMember = members[0]; if (currMember is MethodInfo) { i++; ParserHelper.PushToStack(PrevMember, Method); Method.Box(ParserHelper.GetMemberType(PrevMember)); var callMethodState = new CallMethodState(StateStack, DefinedTypes, AsmBuilder, ((MethodInfo)currMember).DeclaringType, Method); StateStack.Push(callMethodState); callMethodState.Execute(tokens, ref i); return; } else { i += 2; } PrevMember = currMember; } } StateStack.Pop(); }
private void ProcessOperator(IList <Token> tokens, ref int i) { if (tokens[i].Value == "=") { if (!_methodBodyState.UnusedLocals.Contains(tokens[i - 1].Value)) { //todo узнавать, это присвоение значения или результата вычислений, если последнее, то перенаправлять в следующий if var variable = tokens[i - 1].Value; //todo узнавать, переменная, константа или функция (вроде как сделал) ParserHelper.PushToStack(tokens[i + 1].Value, Method, DefinedTypes, TypeBuilder, AsmBuilder); //todo узнавать, переменная или поле (вроде как сделал) var member = ParserHelper.GetMember(variable, DefinedTypes, Method.Locals, TypeBuilder, AsmBuilder); switch (member) { case FieldInfo fieldInfo: Method.StoreField(fieldInfo); break; case Local local: Method.StoreLocal(local); break; default: //todo NotPossibleToSetValue ExceptionManager.ThrowCompiler(ErrorCode.NotPossibleToSetValue, "", tokens[i].Line); break; } } i += 2; } else { var left = tokens[i - 1].Value; var right = tokens[i + 1].Value; //todo узнавать, переменная, константа или функция (вроде как сделал) ParserHelper.PushToStack(left, Method, DefinedTypes, TypeBuilder, AsmBuilder); ParserHelper.PushToStack(right, Method, DefinedTypes, TypeBuilder, AsmBuilder); //todo добавить больше операций switch (tokens[i].Value) { case "+": Method.Add(); break; case "-": Method.Subtract(); break; case "*": Method.Multiply(); break; case "/": Method.Divide(); break; } i += 2; } }
/// <summary> /// Adds ListNext() method for each List method with x-ms-pageable extension. /// </summary> /// <param name="codeModelient"></param> /// <param name="codeNamer"></param> public static void AddPageableMethod(CodeModel codeModel) { if (codeModel == null) { throw new ArgumentNullException("codeModel"); } foreach (var method in codeModel.Methods.Distinct(each => each.Group + each.Name).ToArray()) { if (method.Extensions.ContainsKey(PageableExtension)) { var pageableExtension = JsonConvert.DeserializeObject <PageableExtension>(method.Extensions[PageableExtension].ToString()); if (string.IsNullOrWhiteSpace(pageableExtension.NextLinkName)) { continue; } Method nextLinkMethod = null; if (!string.IsNullOrEmpty(pageableExtension.OperationName)) { nextLinkMethod = codeModel.Methods.FirstOrDefault(m => pageableExtension.OperationName.EqualsIgnoreCase(m.SerializedName)); if (nextLinkMethod != null) { nextLinkMethod.Extensions["nextLinkMethod"] = true; method.Extensions["nextMethodName"] = nextLinkMethod.Name; method.Extensions["nextMethodGroup"] = nextLinkMethod.Group; } } if (nextLinkMethod == null) { nextLinkMethod = Duplicate <Method>(method); if (!string.IsNullOrEmpty(pageableExtension.OperationName)) { nextLinkMethod.Name = CodeNamer.Instance.GetMethodName(SwaggerModeler.GetMethodName( new Operation { OperationId = pageableExtension.OperationName })); nextLinkMethod.Group = CodeNamer.Instance.GetMethodGroupName(SwaggerModeler.GetMethodGroup( new Operation { OperationId = pageableExtension.OperationName })); } else { nextLinkMethod.Name = nextLinkMethod.Name + "Next"; } method.Extensions["nextMethodName"] = nextLinkMethod.Name; method.Extensions["nextMethodGroup"] = nextLinkMethod.Group; nextLinkMethod.Extensions["nextLinkMethod"] = true; nextLinkMethod.ClearParameters(); nextLinkMethod.Url = "{nextLink}"; nextLinkMethod.IsAbsoluteUrl = true; var nextLinkParameter = New <Parameter>(new { Name = "nextPageLink", SerializedName = "nextLink", ModelType = New <PrimaryType>(KnownPrimaryType.String), Documentation = "The NextLink from the previous successful call to List operation.", IsRequired = true, Location = ParameterLocation.Path }); nextLinkParameter.Extensions[SkipUrlEncodingExtension] = true; nextLinkMethod.Add(nextLinkParameter); // Need copy all the header parameters from List method to ListNext method foreach (var param in method.Parameters.Where(p => p.Location == ParameterLocation.Header)) { nextLinkMethod.Add(Duplicate(param)); } // Copy all grouped parameters that only contain header parameters nextLinkMethod.InputParameterTransformation.Clear(); method.InputParameterTransformation.GroupBy(t => t.ParameterMappings[0].InputParameter) .ForEach(grouping => { if (grouping.All(t => t.OutputParameter.Location == ParameterLocation.Header)) { // All grouped properties were header parameters, reuse data type nextLinkMethod.Add(grouping.Key); grouping.ForEach(t => nextLinkMethod.InputParameterTransformation.Add(t)); } else if (grouping.Any(t => t.OutputParameter.Location == ParameterLocation.Header)) { // Some grouped properties were header parameters, creating new data types var headerGrouping = grouping.Where(t => t.OutputParameter.Location == ParameterLocation.Header); headerGrouping.ForEach(t => nextLinkMethod.InputParameterTransformation.Add((ParameterTransformation)t.Clone())); var newGroupingParam = CreateParameterFromGrouping(headerGrouping, nextLinkMethod, codeModel); nextLinkMethod.Add(newGroupingParam); //grouping.Key.Name = newGroupingParam.Name; // var inputParameter = (Parameter) nextLinkMethod.InputParameterTransformation.First().ParameterMappings[0].InputParameter.Clone(); var inputParameter = Duplicate(nextLinkMethod.InputParameterTransformation.First().ParameterMappings[0].InputParameter); inputParameter.Name = CodeNamer.Instance.GetParameterName(newGroupingParam.Name); inputParameter.IsRequired = newGroupingParam.IsRequired; nextLinkMethod.InputParameterTransformation.ForEach(t => t.ParameterMappings[0].InputParameter = inputParameter); } }); codeModel.Add(nextLinkMethod); } } } }
// ---------------------------------------------------------------------------------------- /// <!-- Add --> /// <summary> /// /// </summary> /// <param name="methodName"></param> public void Add(string methodName) { Method.Add(methodName); }