예제 #1
0
        /// <summary>
        /// Constructor.
        /// </summary>
        public EditArrayVariable(ParserItem _item, Request _request)
        {
            // Set title, icon, resizable
            Title = Director.Properties.Resources.EditVariable;
            Icon = Image.FromResource (DirectorImages.EDIT_CONTENT_ICON);
            Resizable = false;

            // Set variables
            ActiveItem = _item;
            ActiveRequest = _request;

            // Widht height
            Width = 520;
            Height = 330;

            // Init components
            _initializeComponents ();

            // Add buttons
            Buttons.Add (new DialogButton (Director.Properties.Resources.ConfirmInput, Command.Ok));
            Buttons.Add (new DialogButton (Director.Properties.Resources.Cancel, Command.Cancel));

            // Parse data
            ParseData ();
        }
예제 #2
0
        void DrawColorProperty(string key, string value, Color c, ParserItem item, bool comma = true)
        {
            if (CanDraw)
            {
                double newX = X;
                if (key != null) {
                    var Item = CreateTextLayout (string.Format ("\"{0}\" : ", key));
                    CTX.DrawTextLayout (Item, X, Y);
                    newX = X + Item.GetSize ().Width;
                }

                if (DrawVisibleProperty == false) {
                    CTX.DrawTextLayout (CreateTextLayout(value), newX, Y);
                    return;
                }

                // Create value
                var Value = new TextLayout();
                Value.Font.WithSize(10);
                Value.Text = value;
                var s = Value.GetSize();
                var rect = new Rectangle(newX, Y, s.Width, s.Height).Inflate(0.2, 0.2);
                CreateClickableItem((double) newX, (double)Y, s.Width, s.Height, item);
                CTX.SetColor(c);
                CTX.Rectangle(rect);
                CTX.Fill();
                CTX.SetLineWidth(1);
                CTX.Stroke();
                CTX.SetColor(Colors.White);
                CTX.DrawTextLayout(Value, newX, Y);
                CTX.SetColor(Colors.Black);

                if (comma)
                {
                    var end = CreateTextLayout(",");
                    CTX.DrawTextLayout(end, newX + s.Width + 8, Y);
                }
            }
        }
예제 #3
0
        void DrawArrayProperty(string key, ParserItem it)
        {
            if (CanDraw) {
                // Create Key Item
                var KeyItem = CreateTextLayout(string.Format("\"{0}\"", key));

                // Create rectangle
                var rect = new Rectangle (X, Y, KeyItem.GetSize().Width, KeyItem.GetSize().Height).Inflate (0.2, 0.2);

                // Clikable item
                CreateClickableItem((double) X, (double)Y, KeyItem.GetSize().Width, KeyItem.GetSize().Height, it);

                // Draw rect
                CTX.SetColor(Colors.DarkGreen);
                CTX.Rectangle(rect);
                CTX.Fill();
                CTX.SetLineWidth(1);
                CTX.Stroke();
                CTX.SetColor(Colors.White);
                CTX.DrawTextLayout(KeyItem, X, Y);
                CTX.SetColor(Colors.Black);

                // Draw [
                double newX = X + KeyItem.GetSize ().Width + 0.2;
                CTX.DrawTextLayout (CreateTextLayout (" : ["), newX, Y);
            }
        }
예제 #4
0
        /// <summary>
        /// Create clickable item on target destination!
        /// </summary>
        private void CreateClickableItem(double corX, double corY, double corWidth, double corHeight, ParserItem item)
        {
            if (hscroll != null && vscroll != null)
            {
                corX -= hscroll.Value;
                corY -= vscroll.Value;
            }

            // Not clickable (out of range)
            if (corX < 0 || corY < 0)
                return;

            // Create Item
            CanvasItems.Add(
                new ClickableResponseItem()
                {
                    X = corX, Y = corY, Height = corY + corHeight, Width = corX + corWidth, Item = item
                }
            );
        }
예제 #5
0
        /// <summary>
        /// This auxiliary method tries to parse passed string arguments and generate next integer value of particular sequence according to specification.
        /// </summary>
        /// <param name="function_arguments"></param>
        /// <param name="errors"></param>
        /// <param name="item"></param>
        /// <param name="parsing_offset"></param>
        /// <param name="customVariables"></param>
        /// <returns></returns>
        private string applyRequestFunctionSequence(string[] function_arguments, List<ParserError> errors, ParserItem item, int parsing_offset, Dictionary<string, string> customVariables)
        {
            bool new_sequence = false; // this variable determines whether we do need to create new custom variable to hold current value of the sequence
            int current_value = Int32.MinValue;

            // check number of arguments
            if (function_arguments.Length != 4)
            {
                errors.Add(new ParserError(item.line, item.position + parsing_offset, ERR_MSG_INVALID_NUMBER_OF_ARGUMENTS, SOURCE_TEMPLATE));
                return null;
            }

            // parse arguments
            int original_errors_count = errors.Count;
            int start = parse_integer_function_argument(function_arguments[0], errors, item, parsing_offset); // parse first argument
            int end = function_arguments[1].Length>0 ? parse_integer_function_argument(function_arguments[1], errors, item, parsing_offset) : Int32.MinValue; // parse second argument (might be empty)
            int increment = parse_integer_function_argument(function_arguments[2], errors, item, parsing_offset); // parse third argument
            // parse fourth argument
            if (!customVariables.ContainsKey(function_arguments[3]))
            {
                new_sequence = true; // unknown custom variable - set up a new custom variable containing start of the sequence below
            }
            else
            {
                // value of custom variable passed in 4th argument must contain integer value
                current_value = parse_integer_function_argument(customVariables[function_arguments[3]], errors, item, parsing_offset);
            }
            if (errors.Count > original_errors_count) // if some new errors occured during parsing of the arguments ...
                return null; // ... stop evaluating and leave this code block

            // generate a new number of this sequence based on passed arguments and return it as a string
            int next_sequence_number;
            if (new_sequence)
            {
                customVariables[function_arguments[3]] = Convert.ToString(start, culture);
                next_sequence_number = start;
            }
            else
            {
                if (end == Int32.MinValue)
                {
                    // second argument was not provided - simply add increment to current value
                    next_sequence_number = current_value + increment;
                }
                else
                {
                    // second argument was provided - add increment to current value, but loop it from start if it exceeds end
                    next_sequence_number = current_value + increment;
                    if ((increment > 0 && next_sequence_number > end) || (increment < 0 && next_sequence_number < end))
                        next_sequence_number = start; // reset sequence
                }
                customVariables[function_arguments[3]] = Convert.ToString(next_sequence_number, culture); // save new sequence value for next request
            }
            return "" + next_sequence_number;
        }
예제 #6
0
        /// <summary>
        /// This auxiliary method tries to parse passed string arguments and generate random integer according to specification.
        /// </summary>
        /// <param name="function_arguments"></param>
        /// <param name="errors"></param>
        /// <param name="item"></param>
        /// <param name="parsing_offset"></param>
        /// <returns></returns>
        private string applyRequestFunctionRandInt(string[] function_arguments, List<ParserError> errors, ParserItem item, int parsing_offset)
        {
            // check number of arguments
            if (function_arguments.Length != 2)
            {
                errors.Add(new ParserError(item.line, item.position + parsing_offset, ERR_MSG_INVALID_NUMBER_OF_ARGUMENTS, SOURCE_TEMPLATE));
                return null;
            }

            // parse arguments
            int original_errors_count = errors.Count;
            int min_range = parse_integer_function_argument(function_arguments[0], errors, item, parsing_offset); // parse first argument
            int max_range = parse_integer_function_argument(function_arguments[1], errors, item, parsing_offset); // parse second argument
            if (errors.Count > original_errors_count) // if some new errors occured during parsing of the arguments ...
                return null; // ... stop evaluating and leave this code block

            // check whether first arg. is smaller or equal that the second one
            if (min_range > max_range)
            {
                errors.Add(new ParserError(item.line, item.position + parsing_offset, string.Format(ERR_MSG_ARGUMENTS_WRONG_SIZED, 1, function_arguments[1], 2, function_arguments[2]), SOURCE_TEMPLATE));
                return null;
            }

            // generate random integer between the value of first and second argument and return it as a string
            return "" + this.random.Next(min_range, max_range + 1);
        }
예제 #7
0
 /// <summary>
 /// This auxiliary method tries to convert string argument to integer and if it fails to do so error is added to the errors list.
 /// </summary>
 /// <param name="argument"></param>
 /// <param name="errors"></param>
 /// <param name="item"></param>
 /// <param name="parsing_offset"></param>
 /// <returns></returns>
 private int parse_integer_function_argument(string argument, List<ParserError> errors, ParserItem item, int parsing_offset)
 {
     int result = Int32.MinValue;
     try
     {
         result = Convert.ToInt32(argument, culture);
     }
     catch (FormatException)
     {
         errors.Add(new ParserError(item.line, item.position + parsing_offset, string.Format(ERR_MSG_ARGUMENT_NOT_INTEGER, argument), SOURCE_TEMPLATE));
     }
     catch (OverflowException)
     {
         errors.Add(new ParserError(item.line, item.position + parsing_offset, string.Format(ERR_MSG_ARGUMENT_TOO_BIG, argument), SOURCE_TEMPLATE));
     }
     return result;
 }
예제 #8
0
        private void PrintArray(string key, ParserItem it, List<ParserItem> list, bool comma = false)
        {
            string commaStr = (comma) ? "," : "";
            bool changed = false;
            // PRint item?
            if (DrawArray && DrawVisibleProperty) {
                DrawArrayProperty (key, it);
                DrawVisibleProperty = false;
                changed = true;
            } else if (key != null)
            {
                DrawText(string.Format("\"{0}\" : ", key) + "[");
            }
            else
                DrawText("[");

            X += 20;
            NextLine();
            var lastItem = list[list.Count - 1];
            foreach (var item in list)
            {
                DrawParserItem(null, item, item != lastItem);
            }

            X -= 20;
            DrawText("]" + commaStr);

            if (changed)
                DrawVisibleProperty = true;
        }
예제 #9
0
        private ParserItem parseCompareRules(ParserItem item, Dictionary<string, string> customVariables, List<ParserError> errors)
        {
            string value = (string)item.value;
            int original_error_count = errors.Count;

            // find out all positions of MAIN_SYNTAX_CHARACTERs in the string value
            List<int> occurrences = new List<int>();
            int index = 0;
            do
            {
                index = value.IndexOf(MAIN_SYNTAX_CHARACTER, index); // ... so, find all occurrences of function characters in given string value
                if (index != -1)
                {
                    if (index == 0 || value[index - 1] != ESCAPE_CHARACTER) // either first character or unescaped one
                        occurrences.Add(index);
                    index++;
                }
            } while (index != -1);
            List<int> original_occurrences = new List<int>(occurrences); // when we notify the user about parser error we want to refer to the positions from original template

            // take care of possibility that we got a plain string without any MAIN_SYNTAX_CHARACTERs
            if (occurrences.Count == 0)
            {
                item.comp_def = new ParserCompareDefinition();
                item.comp_def.type = typeof(string);
                item.comp_def.value = value;
                return item;
            }

            // take care of possible errors
            if (occurrences.Count < 5) // not enough MAIN_SYNTAX_CHARACTERs
                errors.Add(new ParserError(item.line, item.position + original_occurrences.Last(), string.Format(ERR_MSG_EXPECTING_CHARACTER, MAIN_SYNTAX_CHARACTER), SOURCE_TEMPLATE));
            if (occurrences.Count > 5) // too many MAIN_SYNTAX_CHARACTERs
                errors.Add(new ParserError(item.line, item.position + original_occurrences[5], string.Format(ERR_MSG_INVALID_CHARACTER, MAIN_SYNTAX_CHARACTER), SOURCE_TEMPLATE));
            if (occurrences.First() != 0) // illegal characters before first MAIN_SYNTAX_CHARACTER
                errors.Add(new ParserError(item.line, item.position, string.Format(ERR_MSG_INVALID_CHARACTER, value[0]), SOURCE_TEMPLATE));
            if (occurrences.Last() != value.Length - 1) // illegal characters after last MAIN_SYNTAX_CHARACTER
                errors.Add(new ParserError(item.line, item.position + original_occurrences.Last(), string.Format(ERR_MSG_INVALID_CHARACTER, value[original_occurrences.Last() + 1]), SOURCE_TEMPLATE));

            // if there are any new syntax errors we can't parse this item - return it without any change
            if (errors.Count > original_error_count)
                return item;

            // now  we can replace all escaped MAIN_SYNTAX_CHARACTER for the real ones
            // note: all concerned indices in occurrences list must be modified accordingly, since ESCAPE_CHARACTERs are being taken
            // out from the original string
            index = 0;
            do
            {
                index = value.IndexOf("" + ESCAPE_CHARACTER + MAIN_SYNTAX_CHARACTER, index); // find escaped MAIN_SYNTAX_CHARACTER
                if (index != -1)
                {
                    value = value.Remove(index, 1); // remove ESCAPE_CHARACTER from the string
                    // all occurrences with further placement than index of escaped character must be corrected by one
                    shift_occurrences(occurrences, index, -1);
                    index++;
                }
            } while (index != -1);

            //
            // retrieve individual values between MAIN_SYNTAX_CHARACTERs and save them to the item structure
            //
            string type = value.Substring(occurrences[0] + 1, occurrences[1] - occurrences[0] - 1); // type
            string[] ops = value.Substring(occurrences[1] + 1, occurrences[2] - occurrences[1] - 1).Split(new char[] {RESPONSE_OPERATION_SEPARATOR}, StringSplitOptions.RemoveEmptyEntries); // operation with possible modifiers
            string val = value.Substring(occurrences[2] + 1, occurrences[3] - occurrences[2] - 1); // value
            string var = value.Substring(occurrences[3] + 1, occurrences[4] - occurrences[3] - 1); // variable
            ParserCompareDefinition pcd = new ParserCompareDefinition();

            // type
            if (type.Length > 0)
            {
                switch (type)
                {
                    case RESPONSE_TYPE_STRING:
                        pcd.type = typeof(string);
                        break;
                    case RESPONSE_TYPE_INTEGER:
                        pcd.type = typeof(int);
                        break;
                    case RESPONSE_TYPE_FLOAT:
                        pcd.type = typeof(float);
                        break;
                    case RESPONSE_TYPE_BOOLEAN:
                        pcd.type = typeof(bool);
                        break;
                    case RESPONSE_TYPE_OBJECT:
                        pcd.type = typeof(object);
                        break;
                    case RESPONSE_TYPE_ARRAY:
                        pcd.type = typeof(Array);
                        break;
                    default: // urecognized type
                        errors.Add(new ParserError(item.line, item.position + 1, string.Format(ERR_MSG_UNKNOWN_TYPE, type), SOURCE_TEMPLATE));
                        break;
                }
            }

            // operation + modifiers
            bool use_var = false; // use variable modifier
            bool if_present = false; // if present modifier
            string op = null; // operation
            if (ops.Length > 0)
            {
                foreach (string ops_item in ops)
                {
                    switch (ops_item)
                    {
                        case RESPONSE_OPERATION_MODIFIER_USE_VARIABLE:
                            use_var = true;
                            break;
                        case RESPONSE_OPERATION_MODIFIER_IF_PRESENT:
                            if_present = true;
                            break;
                        case RESPONSE_OPERATION_EQUAL:
                            if (RESPONSE_OPERATION_EQUAL_ALLOWED_TYPES.Contains(type))
                                op = ops_item;
                            else
                                errors.Add(new ParserError(item.line, item.position + original_occurrences[1] + 1, string.Format(ERR_MSG_OPERATION_DOESNT_SUPPORT_TYPE, ops_item, type), SOURCE_TEMPLATE));
                            break;
                        case RESPONSE_OPERATION_NOT_EQUAL:
                            if (RESPONSE_OPERATION_NOT_EQUAL_ALLOWED_TYPES.Contains(type))
                                op = ops_item;
                            else
                                errors.Add(new ParserError(item.line, item.position + original_occurrences[1] + 1, string.Format(ERR_MSG_OPERATION_DOESNT_SUPPORT_TYPE, ops_item, type), SOURCE_TEMPLATE));
                            break;
                        case RESPONSE_OPERATION_LESS_THAN:
                            if (RESPONSE_OPERATION_LESS_THAN_ALLOWED_TYPES.Contains(type))
                                op = ops_item;
                            else
                                errors.Add(new ParserError(item.line, item.position + original_occurrences[1] + 1, string.Format(ERR_MSG_OPERATION_DOESNT_SUPPORT_TYPE, ops_item, type), SOURCE_TEMPLATE));
                            break;
                        case RESPONSE_OPERATION_LESS_THAN_OR_EQUAL:
                            if (RESPONSE_OPERATION_LESS_THAN_OR_EQUAL_ALLOWED_TYPES.Contains(type))
                                op = ops_item;
                            else
                                errors.Add(new ParserError(item.line, item.position + original_occurrences[1] + 1, string.Format(ERR_MSG_OPERATION_DOESNT_SUPPORT_TYPE, ops_item, type), SOURCE_TEMPLATE));
                            break;
                        case RESPONSE_OPERATION_GREATER_THAN:
                            if (RESPONSE_OPERATION_GREATER_THAN_ALLOWED_TYPES.Contains(type))
                                op = ops_item;
                            else
                                errors.Add(new ParserError(item.line, item.position + original_occurrences[1] + 1, string.Format(ERR_MSG_OPERATION_DOESNT_SUPPORT_TYPE, ops_item, type), SOURCE_TEMPLATE));
                            break;
                        case RESPONSE_OPERATION_GREATER_THAN_OR_EQUAL:
                            if (RESPONSE_OPERATION_GREATER_THAN_OR_EQUAL_ALLOWED_TYPES.Contains(type))
                                op = ops_item;
                            else
                                errors.Add(new ParserError(item.line, item.position + original_occurrences[1] + 1, string.Format(ERR_MSG_OPERATION_DOESNT_SUPPORT_TYPE, ops_item, type), SOURCE_TEMPLATE));
                            break;
                        case RESPONSE_OPERATION_MATCHING_REGEXP_PATTERN:
                            if (RESPONSE_OPERATION_MATCHING_REGEXP_PATTERN_ALLOWED_TYPES.Contains(type))
                                op = ops_item;
                            else
                                errors.Add(new ParserError(item.line, item.position + original_occurrences[1] + 1, string.Format(ERR_MSG_OPERATION_DOESNT_SUPPORT_TYPE, ops_item, type), SOURCE_TEMPLATE));
                            break;
                        default: // urecognized operation type
                            errors.Add(new ParserError(item.line, item.position + original_occurrences[1] + 1, string.Format(ERR_MSG_UNKNOWN_OPERATION, ops_item), SOURCE_TEMPLATE));
                            break;
                    }
                }

                // assign operation and modifiers into parser compare definition object
                pcd.use_variable = use_var;
                pcd.if_present = if_present;
                pcd.operation = op;

                // if operation was specified, type must be also specified
                if (pcd.type == null && pcd.operation != null)
                    errors.Add(new ParserError(item.line, item.position + 1, ERR_MSG_MISING_TYPE_FOR_OPERATION, SOURCE_TEMPLATE));

            }

            // value
            if (val.Length > 0)
            {
                if (use_var) // do we want to replace variable name in value field by it's actual value?
                {
                    if (customVariables.ContainsKey(val)) // search for desired custom variable ...
                    {
                        // try to convert value of parsed variable name to desired type; if that is not possible add an error
                        pcd.value = convertToDesiredType(pcd.type, customVariables[val], item, errors, original_occurrences);
                    }
                    else // ... and add error if it doesn't exist
                        errors.Add(new ParserError(item.line, item.position + original_occurrences[2] + 1, string.Format(ERR_MSG_UNKNOWN_CUSTOM_VARIABLE, val), SOURCE_TEMPLATE));
                }
                else
                {
                    // try to convert parsed value to desired type; if that is not possible add an error
                    pcd.value = convertToDesiredType(pcd.type, val, item, errors, original_occurrences);
                }
            }
            else
            {
                // in case that every part of possible information from syntax string is missing, let's presume empty string
                if (occurrences[4] - occurrences[0] == 4)
                    pcd.value = "";
            }

            // variable
            if (var.Length > 0)
                pcd.var_name = var;

            // if there are any new syntax errors we can't parse this item - return it without any change
            if (errors.Count > original_error_count)
                return item;

            // assign newly constructed parser compare definition object into item and return the item
            item.comp_def = pcd;
            return item;
        }
예제 #10
0
 /// <summary>
 /// This auxiliary method tries to convert string argument to float and if it fails to do so error is added to the errors list.
 /// </summary>
 /// <param name="argument"></param>
 /// <param name="errors"></param>
 /// <param name="item"></param>
 /// <param name="parsing_offset"></param>
 /// <returns></returns>
 private float parse_float_function_argument(string argument, List<ParserError> errors, ParserItem item, int parsing_offset)
 {
     float result = Single.MinValue;
     try
     {
         result = Convert.ToSingle(argument, culture);
     }
     catch (FormatException)
     {
         errors.Add(new ParserError(item.line, item.position + parsing_offset, string.Format(ERR_MSG_ARGUMENT_NOT_FLOAT, argument), SOURCE_TEMPLATE));
     }
     catch (OverflowException)
     {
         errors.Add(new ParserError(item.line, item.position + parsing_offset, string.Format(ERR_MSG_ARGUMENT_TOO_BIG, argument), SOURCE_TEMPLATE));
     }
     return result;
 }
예제 #11
0
        private object convertToDesiredType(System.Type desired_type, string value, ParserItem item, List<ParserError> errors, List<int> original_occurrences)
        {
            object result = null;

            if (desired_type == null)
            {
                // type was not provided => we will try to assume the closest type possible
                try
                {
                    result = Convert.ToInt32(value, culture); // is it integer?
                }
                catch (Exception)
                {
                    try
                    {
                        result = Convert.ToSingle(value, culture); // is it float?
                    }
                    catch (Exception)
                    {
                        if (value == RESPONSE_BOOLEAN_CONVERSION_TYPE_DEFINITION_TRUE || value == RESPONSE_BOOLEAN_CONVERSION_TYPE_DEFINITION_FALSE) // is it boolean?
                        {
                            if (value == RESPONSE_BOOLEAN_CONVERSION_TYPE_DEFINITION_TRUE)
                                result = true;
                            else
                                result = false;
                        }
                        else
                        {
                            result = value; // let's assume that it's string
                        }
                    }
                }

            }
            else if (desired_type == typeof(string))
            {
                // we don't need to convert anything here, just assign the value
                result = value;
            }
            else if (desired_type == typeof(int) || desired_type == typeof(Array))
            {
                // try to convert value to integer
                try
                {
                    result = Convert.ToInt32(value, culture);
                }
                catch (FormatException)
                {
                    errors.Add(new ParserError(item.line, item.position + original_occurrences[2] + 1, string.Format(ERR_MSG_ARGUMENT_NOT_INTEGER, value), SOURCE_TEMPLATE));
                }
                catch (OverflowException)
                {
                    errors.Add(new ParserError(item.line, item.position + original_occurrences[2] + 1, string.Format(ERR_MSG_ARGUMENT_TOO_BIG, value), SOURCE_TEMPLATE));
                }
            }
            else if (desired_type == typeof(float))
            {
                // try to convert value to float
                try
                {
                    result = Convert.ToSingle(value, culture);
                }
                catch (FormatException)
                {
                    errors.Add(new ParserError(item.line, item.position + original_occurrences[2] + 1, string.Format(ERR_MSG_ARGUMENT_NOT_FLOAT, value), SOURCE_TEMPLATE));
                }
                catch (OverflowException)
                {
                    errors.Add(new ParserError(item.line, item.position + original_occurrences[2] + 1, string.Format(ERR_MSG_ARGUMENT_TOO_BIG, value), SOURCE_TEMPLATE));
                }
            }
            else if (desired_type == typeof(bool))
            {
                if (value == RESPONSE_BOOLEAN_CONVERSION_TYPE_DEFINITION_TRUE || value == RESPONSE_BOOLEAN_CONVERSION_TYPE_DEFINITION_FALSE)
                {
                    if (value == RESPONSE_BOOLEAN_CONVERSION_TYPE_DEFINITION_TRUE)
                        result = true;
                    else
                        result = false;
                }
                else
                {
                    errors.Add(new ParserError(item.line, item.position + original_occurrences[2] + 1, string.Format(ERR_MSG_VALUE_UNCONVERTABLE_TO_TYPE, value, desired_type), SOURCE_TEMPLATE));
                }
            }
            else if (desired_type == typeof(object))
            {
                try
                {
                    result = deserialize(value, errors, SOURCE_TEMPLATE);
                }
                catch (JsonException)
                {
                    errors.Add(new ParserError(item.line, item.position + original_occurrences[2] + 1, string.Format(ERR_MSG_VALUE_UNCONVERTABLE_TO_TYPE, value, desired_type), SOURCE_TEMPLATE));
                }
            }
            else
            {
                errors.Add(new ParserError(item.line, item.position + 1, string.Format(ERR_MSG_UNKNOWN_TYPE, desired_type), SOURCE_TEMPLATE));
            }

            return result;
        }
예제 #12
0
        public static Dictionary<string, ParserItem> deserialize(string template, List<ParserError> errors, string source)
        {
            Dictionary<string, ParserItem> result = new Dictionary<string, ParserItem>();
            JsonTextReader reader = new JsonTextReader(new StringReader(template));
            List<object> indent_path = new List<object>();
            string found_key = null;

            try
            {
                while (reader.Read())
                {
                    if (reader.TokenType == JsonToken.PropertyName)
                    {
                        found_key = (string)reader.Value;
                    }

                    // simple type
                    if (
                        reader.TokenType == JsonToken.String ||
                        reader.TokenType == JsonToken.Integer ||
                        reader.TokenType == JsonToken.Float ||
                        reader.TokenType == JsonToken.Boolean ||
                        reader.TokenType == JsonToken.Null
                    )
                    {
                        if (indent_path.Count > 0)
                        {
                            ParserItem item = new ParserItem(reader.LineNumber, reader.LinePosition, reader.Value);

                            if (indent_path.Last() is Dictionary<string, ParserItem>)
                            {
                                // we are parsing element of object on this level
                                ((Dictionary<string, ParserItem>)indent_path.Last()).Add(found_key, item);
                                found_key = null;
                            }
                            else
                            {
                                // we are parsing element of array on this level
                                ((List<ParserItem>)indent_path.Last()).Add(item);
                            }
                        }
                        else
                            errors.Add(new ParserError(reader.LineNumber, reader.LinePosition, string.Format(ERR_MSG_EXPECTING_CHARACTER, "{"), source));
                    }

                    if (reader.TokenType == JsonToken.StartObject)
                    {
                        if (indent_path.Count == 0)
                        {
                            indent_path.Add(result);
                        }
                        else
                        {
                            Dictionary<string, ParserItem> sub_node = new Dictionary<string, ParserItem>(); // create new node for new object
                            ParserItem item = new ParserItem(reader.LineNumber, reader.LinePosition, sub_node);

                            if (indent_path.Last() is Dictionary<string, ParserItem>)
                            {
                                // we are parsing element of object on this level
                                ((Dictionary<string, ParserItem>)indent_path.Last()).Add(found_key, item);
                                found_key = null;
                            }
                            else
                            {
                                // we are parsing element of array on this level
                                ((List<ParserItem>)indent_path.Last()).Add(item);
                            }

                            indent_path.Add(sub_node); // add new active saving location to the end of this list
                        }
                    }

                    if (reader.TokenType == JsonToken.EndObject)
                    {
                        if (indent_path.Count > 0)
                            indent_path.RemoveAt(indent_path.Count - 1); // remove last element
                        else // too many of closing parentheses
                            errors.Add(new ParserError(reader.LineNumber, reader.LinePosition, string.Format(ERR_MSG_EXPECTING_CHARACTER, "{"), source));
                    }

                    if (reader.TokenType == JsonToken.StartArray)
                    {
                        List<ParserItem> sub_node = new List<ParserItem>(); // create new node for new array
                        ParserItem item = new ParserItem(reader.LineNumber, reader.LinePosition, sub_node);

                        if (indent_path.Last() is Dictionary<string, ParserItem>)
                        {
                            // we are parsing element of object on this level
                            ((Dictionary<string, ParserItem>)indent_path.Last()).Add(found_key, item);
                            found_key = null;
                        }
                        else
                        {
                            // we are parsing element of array on this level
                            ((List<ParserItem>)indent_path.Last()).Add(item);
                        }

                        indent_path.Add(sub_node); // add new active saving location to the end of this list
                    }

                    if (reader.TokenType == JsonToken.EndArray)
                    {
                        if (indent_path.Count > 0)
                            indent_path.RemoveAt(indent_path.Count - 1); // remove last element
                        else // too many of closing parentheses
                            errors.Add(new ParserError(reader.LineNumber, reader.LinePosition, string.Format(ERR_MSG_EXPECTING_CHARACTER, "["), source));
                    }
                }

                // too many of opening parentheses
                if (indent_path.Count > 0)
                {
                    if (indent_path.Last() is Dictionary<string, ParserItem>)
                        errors.Add(new ParserError(reader.LineNumber, reader.LinePosition, string.Format(ERR_MSG_EXPECTING_CHARACTER, "}"), source));
                    else
                        errors.Add(new ParserError(reader.LineNumber, reader.LinePosition, string.Format(ERR_MSG_EXPECTING_CHARACTER, "]"), source));
                }
            }
            catch (JsonException e)
            {
                // an error occured during deserializon => basic syntax of json template is wrong
                errors.Add(createError(e.Message, source));
            }

            return result;
        }
예제 #13
0
        private bool compareParserItems(ParserItem template_item, ParserItem response_item, Dictionary<string, string> customVariables, List<ParserError> errors)
        {
            // preprocess string type which might need to be measured by it's length
            if (template_item.comp_def.type == typeof(string) && template_item.comp_def.operation != RESPONSE_OPERATION_EQUAL && template_item.comp_def.operation != RESPONSE_OPERATION_NOT_EQUAL && template_item.comp_def.operation != RESPONSE_OPERATION_MATCHING_REGEXP_PATTERN && template_item.comp_def.operation != null)
            {
                template_item.comp_def.value = template_item.comp_def.value != null ? ((string)template_item.comp_def.value).Length : 0;
                response_item.value = ((string)response_item.value).Length;
            }

            // unify values of int and float family type members on the same type
            if (template_item.comp_def.value != null && RESPONSE_COMPARISON_FAMILY_TYPE_INTEGERS.Contains(template_item.comp_def.value.GetType()))
                template_item.comp_def.value = Convert.ToInt32(template_item.comp_def.value, culture);
            if (response_item.value != null && RESPONSE_COMPARISON_FAMILY_TYPE_INTEGERS.Contains(response_item.value.GetType()))
                response_item.value = Convert.ToInt32(response_item.value, culture);
            if (template_item.comp_def.value != null && RESPONSE_COMPARISON_FAMILY_TYPE_FLOATS.Contains(template_item.comp_def.value.GetType()))
                template_item.comp_def.value = Convert.ToSingle(template_item.comp_def.value, culture);
            if (response_item.value != null && RESPONSE_COMPARISON_FAMILY_TYPE_FLOATS.Contains(response_item.value.GetType()))
                response_item.value = Convert.ToSingle(response_item.value, culture);

            // response value might have been parsed as integer type, but we still want to be able to compare it with float type template value
            if (RESPONSE_COMPARISON_FAMILY_TYPE_INTEGERS.Contains(response_item.value.GetType()) &&
                (
                    (
                        template_item.comp_def.value != null &&
                        RESPONSE_COMPARISON_FAMILY_TYPE_FLOATS.Contains(template_item.comp_def.value.GetType())
                    ) ||
                    RESPONSE_COMPARISON_FAMILY_TYPE_FLOATS.Contains(template_item.comp_def.type)
                )
            )
            {
                response_item.value = Convert.ToSingle(response_item.value, culture);
            }

            // store value in custom variable if requested
            if (template_item.comp_def.var_name != null)
                customVariables[template_item.comp_def.var_name] = Convert.ToString(response_item.value, culture);

            // strict comparison
            if (template_item.comp_def.type == null && template_item.comp_def.operation == null && template_item.comp_def.value != null)
            {
                if (template_item.comp_def.value.Equals(response_item.value))
                    return true;
                else
                {
                    errors.Add(new ParserError(template_item.line, template_item.position, string.Format(ERR_MSG_COMPARE_VALUES, template_item.comp_def.value, response_item.value), SOURCE_TEMPLATE));
                    return false;
                }
            }

            // type comparison
            if (template_item.comp_def.type != null && template_item.comp_def.operation == null && template_item.comp_def.value == null)
            {
                if (template_item.comp_def.type == response_item.value.GetType())
                    return true;
                else
                {
                    errors.Add(new ParserError(template_item.line, template_item.position, string.Format(ERR_MSG_COMPARE_TYPES, template_item.comp_def.type, response_item.value.GetType()), SOURCE_TEMPLATE));
                    return false;
                }
            }

            // combined comparison (strict + type)
            if (template_item.comp_def.type != null && template_item.comp_def.operation == null && template_item.comp_def.value != null)
            {
                if ((template_item.comp_def.value.Equals(response_item.value)) && (template_item.comp_def.type == response_item.value.GetType()))
                    return true;
                else
                {
                    if (template_item.comp_def.value.Equals(response_item.value))
                        errors.Add(new ParserError(template_item.line, template_item.position, string.Format(ERR_MSG_COMPARE_TYPES, template_item.comp_def.type, response_item.value.GetType()), SOURCE_TEMPLATE));
                    else
                        errors.Add(new ParserError(template_item.line, template_item.position, string.Format(ERR_MSG_COMPARE_VALUES, template_item.comp_def.value, response_item.value), SOURCE_TEMPLATE));
                    return false;
                }
            }

            // specific comparison (operation)
            if (template_item.comp_def.type != null && template_item.comp_def.operation != null && template_item.comp_def.value != null)
            {
                // check if type of both items is the same
                if (template_item.comp_def.value.GetType() != response_item.value.GetType())
                {
                    errors.Add(new ParserError(template_item.line, template_item.position, string.Format(ERR_MSG_COMPARE_TYPES, template_item.comp_def.type, response_item.value.GetType()), SOURCE_TEMPLATE));
                    return false;
                }

                // evaluate comparison with desired operator
                bool result = false;
                switch (template_item.comp_def.operation)
                {
                    case RESPONSE_OPERATION_EQUAL:
                        result = template_item.comp_def.value.Equals(response_item.value);
                        break;
                    case RESPONSE_OPERATION_NOT_EQUAL:
                        result = !template_item.comp_def.value.Equals(response_item.value);
                        break;
                    case RESPONSE_OPERATION_LESS_THAN:
                        if (template_item.comp_def.value is float)
                            result = (float)response_item.value < (float)template_item.comp_def.value;
                        else
                            result = (int)response_item.value < (int)template_item.comp_def.value;
                        break;
                    case RESPONSE_OPERATION_LESS_THAN_OR_EQUAL:
                        if (template_item.comp_def.value is float)
                            result = (float)response_item.value <= (float)template_item.comp_def.value;
                        else
                            result = (int)response_item.value <= (int)template_item.comp_def.value;
                        break;
                    case RESPONSE_OPERATION_GREATER_THAN:
                        if (template_item.comp_def.value is float)
                            result = (float)response_item.value > (float)template_item.comp_def.value;
                        else
                            result = (int)response_item.value > (int)template_item.comp_def.value;
                        break;
                    case RESPONSE_OPERATION_GREATER_THAN_OR_EQUAL:
                        if (template_item.comp_def.value is float)
                            result = (float)response_item.value >= (float)template_item.comp_def.value;
                        else
                            result = (int)response_item.value >= (int)template_item.comp_def.value;
                        break;
                    case RESPONSE_OPERATION_MATCHING_REGEXP_PATTERN:
                        try
                        {
                            // try to match regular expression
                            Match match = Regex.Match((string)response_item.value, (string)template_item.comp_def.value);
                            result = match.Success;
                        }
                        catch (Exception e)
                        {
                            errors.Add(new ParserError(template_item.line, template_item.position, string.Format(ERR_MSG_REGEX_PARSER, e.Message), SOURCE_TEMPLATE));
                        }
                        break;
                    default: // urecognized operation type
                        errors.Add(new ParserError(template_item.line, template_item.position, string.Format(ERR_MSG_UNKNOWN_OPERATION, template_item.comp_def.operation), SOURCE_TEMPLATE));
                        break;
                }

                // evaluate result after comparison
                if (result)
                    return true;
                else
                {
                    errors.Add(new ParserError(template_item.line, template_item.position, string.Format(ERR_MSG_COMPARE_OPERATION, response_item.value, template_item.comp_def.operation, template_item.comp_def.value), SOURCE_TEMPLATE));
                    return false;
                }
            }

            return false;
        }
예제 #14
0
        // Draw item from parser:
        void DrawParserItem(string key, ParserItem item, bool comma = false)
        {
            string commaStr = (comma) ? "," : "";

            if (item.value is Dictionary<string, ParserItem>)
            {
                if (key != null)
                {
                    DrawText(string.Format("\"{0}\" : ", key) + "{");
                } else
                    DrawText("{");

                X += 20;
                NextLine();
                DrawJson((Dictionary<string, ParserItem>)item.value);
                X -= 20;
                DrawText("}" + commaStr);
            }
            else if (item.value is System.String)
            {
                DrawProperty(key, string.Format("\"{0}\"", (string) item.value), item, comma);
            }
            else if (item.value is System.Int64 || item.value is System.Int32 || item.value is System.Double)
            {
               	DrawProperty(key, (item.value + "").Replace(',', '.'), item, comma);
            }
            else if (item.value is System.Boolean)
            {
                    DrawProperty(key, ((System.Boolean) item.value) ? "true" : "false", item, comma);
            }
            else if (item.value == null)
            {
                    DrawProperty(key, "null", item, comma);
            }
            else if (item.value is List<ParserItem>)
            {
                PrintArray(key, item, (List<ParserItem>)item.value, comma);
            }
            else
            {
                DrawText(item.value.GetType().ToString());
            }
            NextLine();
        }
예제 #15
0
        private ParserItem applyFunctions(ParserItem item, Dictionary<string, string> customVariables, List<ParserError> errors)
        {
            string value = (string)item.value;

            // we need to replace variable names surrounded by VARIABLE_CHARACTERs with the actual variables ...
            List<int> var_occurrences = new List<int>();
            int index = 0;
            do
            {
                index = value.IndexOf(VARIABLE_CHARACTER, index); // ... so, find all occurrences of variable characters in given string value
                if (index != -1)
                {
                    if (index == 0 || value[index - 1] != ESCAPE_CHARACTER) // either first character or unescaped one
                        var_occurrences.Add(index);
                    index++;
                }
            } while (index != -1);
            List<int> original_var_occurrences = new List<int>(var_occurrences); // when we notify the user about parser error we want to refer to the positions from original template

            // we need to replace functions surrounded by MAIN_SYNTAX_CHARACTERs with their evaluated result ...
            List<int> fn_occurrences = new List<int>();
            index = 0;
            do
            {
                index = value.IndexOf(MAIN_SYNTAX_CHARACTER, index); // ... so, find all occurrences of function characters in given string value
                if (index != -1)
                {
                    if (index == 0 || value[index - 1] != ESCAPE_CHARACTER) // either first character or unescaped one
                        fn_occurrences.Add(index);
                    index++;
                }
            } while (index != -1);
            List<int> original_fn_occurrences = new List<int>(fn_occurrences); // when we notify the user about parser error we want to refer to the positions from original template

            if (var_occurrences.Count % 2 != 0)
            {
                // last VARIABLE_CHARACTER is missing it's pair ...
                errors.Add(new ParserError(item.line, item.position + original_var_occurrences.Last(), ERR_MSG_MISSING_VARIABLE_CHARACTER, SOURCE_TEMPLATE)); // ... notify the user ...
                var_occurrences.RemoveAt(var_occurrences.Count - 1); // ... and do not try to replace this one in future
            }

            if (fn_occurrences.Count % 2 != 0)
            {
                // last MAIN_SYNTAX_CHARACTER is missing it's pair ...
                errors.Add(new ParserError(item.line, item.position + original_fn_occurrences.Last(), ERR_MSG_MISSING_MAIN_SYNTAX_CHARACTER, SOURCE_TEMPLATE)); // ... notify the user ...
                fn_occurrences.RemoveAt(fn_occurrences.Count - 1); // ... and do not try to replace this one in future
            }

            // now when we have identified all variable occurences, we can replace all escaped VARIABLE_CHARACTER for the real ones
            // note: all concerned indices in occurrences list must be modified accordingly, since ESCAPE_CHARACTERs are being taken
            // out from the original string
            index = 0;
            do
            {
                index = value.IndexOf("" + ESCAPE_CHARACTER + VARIABLE_CHARACTER, index); // find escaped VARIABLE_CHARACTER
                if (index != -1)
                {
                    value = value.Remove(index, 1); // remove ESCAPE_CHARACTER from the string
                    // all occurrences with further placement than index of escaped character must be corrected by one
                    shift_occurrences(var_occurrences, index, -1);
                    shift_occurrences(fn_occurrences, index, -1);
                    index++;
                }
            } while (index != -1);

            // now when we have identified all function occurences, we can replace all escaped MAIN_SYNTAX_CHARACTER for the real ones
            // note: all concerned indices in occurrences list must be modified accordingly, since ESCAPE_CHARACTERs are being taken
            // out from the original string
            index = 0;
            do
            {
                index = value.IndexOf("" + ESCAPE_CHARACTER + MAIN_SYNTAX_CHARACTER, index); // find escaped MAIN_SYNTAX_CHARACTER
                if (index != -1)
                {
                    value = value.Remove(index, 1); // remove ESCAPE_CHARACTER from the string
                    // all occurrences with further placement than index of escaped character must be corrected by one
                    shift_occurrences(var_occurrences, index, -1);
                    shift_occurrences(fn_occurrences, index, -1);
                    index++;
                }
            } while (index != -1);

            // here we need to find out whether VARIABLE_CHARACTER and MAIN_SYNTAX_CHARACTER pairs are not overlaping each other in forbidden way
            // RULES:
            //  - MAIN_SYNTAX_CHARACTER pair can have multiple VARIABLE_CHARACTER pairs inside it
            //  - VARIABLE_CHARACTER pair can not any MAIN_SYNTAX_CHARACTER pairs inside it
            //  - MAIN_SYNTAX_CHARACTER pair can not overlap with VARIABLE_CHARACTER pair and vice versa
            if (var_occurrences.Count > 0 && fn_occurrences.Count > 0) // both pair lists must be non empty for this check to make any sense
            {
                int var_list_position = 0;
                int fn_list_position = 0;
                bool inside_var = false; // whether current position is inside MAIN_SYNTAX_CHARACTER pair or not
                bool inside_fn = false; // whether current position is inside VARIABLE_CHARACTER pair or not

                while (var_list_position < var_occurrences.Count && fn_list_position < fn_occurrences.Count)
                {
                    // current position in both pair lists is not at the end
                    if (var_occurrences[var_list_position] < fn_occurrences[fn_list_position])
                    {
                        inside_var = !inside_var;
                        var_list_position++;
                    }
                    else
                    {
                        if (inside_var && !inside_fn)
                        {
                            // there is MAIN_SYNTAX_CHARACTER inside VARIABLE_CHARACTERs pair - raise an error
                            errors.Add(new ParserError(item.line, item.position + fn_occurrences[fn_list_position], ERR_MSG_FN_INSIDE_VAR, SOURCE_TEMPLATE));
                            // this syntax error is too serious for evaluation to continue - return original item without any change
                            return item;
                        }

                        inside_fn = !inside_fn;
                        fn_list_position++;
                    }
                }
                // upon leaving this while statement, we can be sure that we made it through at least one of the lists
                // the rest does not matter now, since there can't be any more overlaps or bad placements
            }

            // try to match variable names with dictionary of custom variables
            // notify the user if match is not found
            for (int i = 0; i < var_occurrences.Count; i += 2)
            {
                string variable_name = value.Substring(var_occurrences[i] + 1, var_occurrences[i + 1] - var_occurrences[i] - 1); // grab variable name without VARIABLE_CHARACTERs on edges
                if (customVariables.ContainsKey(variable_name)) // is this variable defined in passed custom variables?
                {
                    // replace variable name by it's value
                    value = value.Remove(var_occurrences[i], var_occurrences[i + 1] - var_occurrences[i] + 1); // remove variable name from original string inc. VARIABLE_CHARACTERs on edges
                    value = value.Insert(var_occurrences[i], customVariables[variable_name]); // insert actual value of that variable on the original position
                    // after we changed length of original string by replacing variable name by it's value, we need to change all occurrence indices accordingly
                    shift_occurrences(var_occurrences, var_occurrences[i], customVariables[variable_name].Length - variable_name.Length - 2);
                    shift_occurrences(fn_occurrences, var_occurrences[i], customVariables[variable_name].Length - variable_name.Length - 2);
                }
                else
                {
                    // create new error
                    errors.Add(new ParserError(item.line, item.position + original_var_occurrences[i], string.Format(ERR_MSG_UNKNOWN_CUSTOM_VARIABLE, variable_name), SOURCE_TEMPLATE));
                }
            }

            // update value of the item
            item.value = value;

            // now, we are ready to find and evaluate functions defined in this string
            for (int i = 0; i < fn_occurrences.Count; i += 2)
            {
                string function_string = value.Substring(fn_occurrences[i] + 1, fn_occurrences[i + 1] - fn_occurrences[i] - 1); // grab the function name and it's parameters without MAIN_SYNTAX_CHARACTERs on edges

                int left_parenthesis_position = function_string.IndexOf(REQUEST_FN_LEFT_PARENTHESIS);
                int right_parenthesis_position = function_string.IndexOf(REQUEST_FN_RIGHT_PARENTHESIS);

                // handle all possible syntactical errors
                if (left_parenthesis_position == -1) // no left parenthesis
                    errors.Add(new ParserError(item.line, item.position + fn_occurrences[i], string.Format(ERR_MSG_EXPECTING_CHARACTER, REQUEST_FN_LEFT_PARENTHESIS), SOURCE_TEMPLATE));
                if (right_parenthesis_position == -1) // no right parenthesis
                    errors.Add(new ParserError(item.line, item.position + fn_occurrences[i], string.Format(ERR_MSG_EXPECTING_CHARACTER, REQUEST_FN_RIGHT_PARENTHESIS), SOURCE_TEMPLATE));
                if (left_parenthesis_position != -1 && function_string.IndexOf(REQUEST_FN_LEFT_PARENTHESIS, left_parenthesis_position) == -1) // too many left parentheses
                    errors.Add(new ParserError(item.line, item.position + fn_occurrences[i] + left_parenthesis_position, string.Format(ERR_MSG_INVALID_CHARACTER, REQUEST_FN_LEFT_PARENTHESIS), SOURCE_TEMPLATE));
                if (right_parenthesis_position != -1 && function_string.IndexOf(REQUEST_FN_RIGHT_PARENTHESIS, right_parenthesis_position) == -1) // too many right parentheses
                    errors.Add(new ParserError(item.line, item.position + fn_occurrences[i] + right_parenthesis_position, string.Format(ERR_MSG_INVALID_CHARACTER, REQUEST_FN_RIGHT_PARENTHESIS), SOURCE_TEMPLATE));
                if (left_parenthesis_position == 0) // no function name before left parenthesis
                    errors.Add(new ParserError(item.line, item.position + fn_occurrences[i], ERR_MSG_MISSING_FN_NAME, SOURCE_TEMPLATE));
                if (right_parenthesis_position != function_string.Length - 1) // aditional characters after right parenthesis
                    errors.Add(new ParserError(item.line, item.position + fn_occurrences[i] + right_parenthesis_position, ERR_MSG_UNRECOGNIZED_CHARS_AFTER_FN, SOURCE_TEMPLATE));
                if (left_parenthesis_position > right_parenthesis_position) // swapped parentheses
                    errors.Add(new ParserError(item.line, item.position + fn_occurrences[i] + right_parenthesis_position, ERR_MSG_SWAPPED_PARENTHESES, SOURCE_TEMPLATE));

                // if all basic syntactical conditions are met, we can continue
                if (left_parenthesis_position > 0 && left_parenthesis_position < right_parenthesis_position && right_parenthesis_position == function_string.Length - 1)
                {
                    string function_name = function_string.Substring(0, left_parenthesis_position);
                    string[] function_arguments = function_string.Substring(left_parenthesis_position + 1, right_parenthesis_position - left_parenthesis_position - 1).Split(REQUEST_FN_ARGUMENT_SEPARATOR);
                    for (int j = 0; j < function_arguments.Length; j++)
                        function_arguments[j] = function_arguments[j].Trim(); // trim any white spaces from all arguments
                    string function_result = null;
                    bool type_result = false; // if the entire "value" string is occupied only by one function, we will type the result from string to desired variable type (integer of float)

                    // try to recognize the function name
                    switch (function_name)
                    {
                        case REQUEST_FN_RAND_INT:
                            function_result = applyRequestFunctionRandInt(function_arguments, errors, item, fn_occurrences[i]);
                            if (fn_occurrences.Count == 2 && fn_occurrences[0] == 0 && fn_occurrences[1] == value.Length - 1) // the entire "value" string is occupied only by one function
                                type_result = true; // we will type the result to integer
                            break;
                        case REQUEST_FN_RAND_FLOAT:
                            function_result = applyRequestFunctionRandFloat(function_arguments, errors, item, fn_occurrences[i]);
                            if (fn_occurrences.Count == 2 && fn_occurrences[0] == 0 && fn_occurrences[1] == value.Length - 1) // the entire "value" string is occupied only by one function
                                type_result = true; // we will type the result to float
                            break;
                        case REQUEST_FN_RAND_STRING:
                            function_result = applyRequestFunctionRandString(function_arguments, errors, item, fn_occurrences[i]);
                            break;
                        case REQUEST_FN_SEQUENCE:
                            function_result = applyRequestFunctionSequence(function_arguments, errors, item, fn_occurrences[i], customVariables);
                            if (fn_occurrences.Count == 2 && fn_occurrences[0] == 0 && fn_occurrences[1] == value.Length - 1) // the entire "value" string is occupied only by one function
                                type_result = true; // we will type the result to integer
                            break;
                        default:
                            errors.Add(new ParserError(item.line, item.position + fn_occurrences[i], ERR_MSG_UNRECOGNIZED_FN, SOURCE_TEMPLATE));
                            break;
                    }

                    // if there were no difficulties during function evaluation, we can continue
                    if (function_result != null)
                    {
                        // replace entire function string by the function result
                        value = value.Remove(fn_occurrences[i], fn_occurrences[i + 1] - fn_occurrences[i] + 1); // remove entire function string from original string inc. MAIN_SYNTAX_CHARACTERs on edges
                        value = value.Insert(fn_occurrences[i], function_result); // insert function result on the original position
                        // after we changed length of original string by replacing entire function string by function result, we need to change all occurrence indices accordingly
                        shift_occurrences(fn_occurrences, fn_occurrences[i], function_result.Length - function_string.Length - 2);

                        if (type_result) // the entire "value" string is occupied only by one function, we must type the result to desired one
                        {
                            switch (function_name)
                            {
                                case REQUEST_FN_RAND_INT:
                                    item.value = Convert.ToInt32(value, culture); // type to integer
                                    break;
                                case REQUEST_FN_RAND_FLOAT:
                                    item.value = Convert.ToSingle(value, culture); // type to float
                                    break;
                                case REQUEST_FN_SEQUENCE:
                                    item.value = Convert.ToInt32(value, culture); // type to integer
                                    break;
                                default:
                                    item.value = value;
                                    break;
                            }
                        }
                        else // don't type result to differen type and assign regular string
                        {
                            item.value = value;
                        }
                    }
                }
            }

            // return modified item
            return item;
        }
예제 #16
0
 void DrawProperty(string key, string value, ParserItem it, bool comma = true)
 {
     DrawColorProperty (key, value, Colors.DarkBlue, it, comma);
 }
예제 #17
0
        /// <summary>
        /// This auxiliary method tries to parse passed string arguments and generate random float according to specification.
        /// </summary>
        /// <param name="function_arguments"></param>
        /// <param name="errors"></param>
        /// <param name="item"></param>
        /// <param name="parsing_offset"></param>
        /// <returns></returns>
        private string applyRequestFunctionRandFloat(string[] function_arguments, List<ParserError> errors, ParserItem item, int parsing_offset)
        {
            // check number of arguments
            if (function_arguments.Length != 3)
            {
                errors.Add(new ParserError(item.line, item.position + parsing_offset, ERR_MSG_INVALID_NUMBER_OF_ARGUMENTS, SOURCE_TEMPLATE));
                return null;
            }

            // parse arguments
            int original_errors_count = errors.Count;
            float min_range = parse_float_function_argument(function_arguments[0], errors, item, parsing_offset); // parse first argument
            float max_range = parse_float_function_argument(function_arguments[1], errors, item, parsing_offset); // parse second argument
            int precision = parse_integer_function_argument(function_arguments[2], errors, item, parsing_offset); // parse third argument
            if (errors.Count > original_errors_count) // if some new errors occured during parsing of the arguments ...
                return null; // ... stop evaluating and leave this code block

            // check whether first arg. is smaller or equal that the second one
            if (min_range > max_range)
            {
                errors.Add(new ParserError(item.line, item.position + parsing_offset, string.Format(ERR_MSG_ARGUMENTS_WRONG_SIZED, 1, function_arguments[1], 2, function_arguments[2]), SOURCE_TEMPLATE));
                return null;
            }

            // generate random float between the value of first and second argument with desired number of fractional digits and return it as a string
            return Convert.ToString(Math.Round((this.random.NextDouble() * (max_range - min_range) + min_range), precision), culture);
        }
예제 #18
0
        /// <summary>
        /// Draw parser item
        /// </summary>
        private void DrawParserItem(string key, ParserItem item, bool comma, int spaces)
        {
            AppendSpaces(spaces);
            if (key != null)
                Result += string.Format("\"{0}\" : ", key);

            if (item.value == null)
            {
                Result += "null";
            }
            else if (item.value is Dictionary<string, ParserItem>)
            {
                PrintObject((Dictionary<string, ParserItem>)item.value, spaces);
            }
            else if (item.value is List<ParserItem>)
            {
                Result += "[" + ENDL;
                DrawArray((List<ParserItem>) item.value, spaces + 1);
                AppendSpaces(spaces);
                Result += "]";
            }
            else if (item.value is System.Int64 || item.value is System.Int32 || item.value is System.Double)
            {
                Result += (item.value + "").Replace(',', '.');
            }
            else
            {
                Result += string.Format("\"{0}\"", item.value.ToString());
            }

            // Comma?
            if (comma)
                Result += ",";

            // Endline
            Result += ENDL;
        }
예제 #19
0
        /// <summary>
        /// This auxiliary method tries to parse passed string arguments and generate random string according to specification.
        /// </summary>
        /// <param name="function_arguments"></param>
        /// <param name="errors"></param>
        /// <param name="item"></param>
        /// <param name="parsing_offset"></param>
        /// <returns></returns>
        private string applyRequestFunctionRandString(string[] function_arguments, List<ParserError> errors, ParserItem item, int parsing_offset)
        {
            string character_pool = ""; // this string will eventually contain all desired characters from which we will generate resulting random string

            // check number of arguments
            if (function_arguments.Length != 3)
            {
                errors.Add(new ParserError(item.line, item.position + parsing_offset, ERR_MSG_INVALID_NUMBER_OF_ARGUMENTS, SOURCE_TEMPLATE));
                return null;
            }

            // parse arguments
            int original_errors_count = errors.Count;
            int min_length = parse_integer_function_argument(function_arguments[0], errors, item, parsing_offset); // parse first argument
            int max_length = parse_integer_function_argument(function_arguments[1], errors, item, parsing_offset); // parse second argument
            foreach (char ch in function_arguments[2]) // parse third argument
            {
                if (!REQUEST_FN_RAND_STRING_GROUP_SYMBOLS.Contains(ch)) // each character of third argument must be recognized as symbol for group of characters
                {
                    // symbol for group of characters was not recognized - add an error
                    errors.Add(new ParserError(item.line, item.position + parsing_offset, String.Format(ERR_MSG_ARGUMENT_INVALID, function_arguments[2]), SOURCE_TEMPLATE));
                    break;
                }
                else
                {
                    // symbol for group of characters was recognized - add set of characters represented by this symbol to the character pool
                    character_pool += REQUEST_FN_RAND_STRING_GROUPS[Array.FindIndex(REQUEST_FN_RAND_STRING_GROUP_SYMBOLS, x => x == ch)];
                }
            }
            if (errors.Count > original_errors_count) // if some new errors occured during parsing of the arguments ...
                return null; // ... stop evaluating and leave this code block

            // check whether first arg. is smaller or equal that the second one
            if (min_length > max_length)
            {
                errors.Add(new ParserError(item.line, item.position + parsing_offset, string.Format(ERR_MSG_ARGUMENTS_WRONG_SIZED, 1, function_arguments[1], 2, function_arguments[2]), SOURCE_TEMPLATE));
                return null;
            }

            // generate random string between the lenght of first and second argument with desired type of characters and return it as a string
            int lenght = this.random.Next(min_length, max_length + 1);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < lenght; i++)
               sb.Append(character_pool[this.random.Next(character_pool.Length)]);
            return sb.ToString();
        }