Exemple #1
0
        public void GivenPowerOf4_IsPowerOf_ShouldReturnTrue()
        {
            var result = new PowerOf(4).Build().IsNumberPowerOf(16);

            Assert.IsTrue(result);
        }
Exemple #2
0
        public void GivenPowerOf3_IsPowerOfThree_ShouldReturnTrue()
        {
            var result = new PowerOf(3).Build().IsNumberPowerOf(27);

            Assert.IsTrue(result);
        }
Exemple #3
0
        public void GivenNotPowerOf3_IsPowerOfThree_ShouldReturnFalse()
        {
            var result = new PowerOf(3).Build().IsNumberPowerOf(15);

            Assert.IsFalse(result);
        }
        public SuperHappyScript(string script)
        {
            ValueNode currentNode = null;

            string currentParseValue = "";
            int    predenceLevel     = 0;

            _variables = new List <string>();
            int  index        = 0;
            char currentToken = ' ';
            char nextToken    = ' ';

            _script = script;

            try {
                foreach (char token in script)
                {
                    index++;

                    if (script.Length > index)
                    {
                        nextToken = script[index];
                    }

                    currentToken = token;

                    if (currentParseValue.StartsWith("[") && !currentParseValue.EndsWith("]") && !(currentParseValue + token).EndsWith(">=") && !(currentParseValue + token).EndsWith("<=") && !(currentParseValue + token).EndsWith("<>"))
                    {
                        currentParseValue += token;
                        continue;
                    }

                    if (IgnoreSet.Contains(token))
                    {
                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }
                    }
                    else if (token == ']')
                    {
                        currentParseValue += token;
                        currentNode        = AddValue(currentNode, currentParseValue);
                    }
                    else if (token == ',')
                    {
                        if (predenceLevel == 0)
                        {
                            throw new Exception("Parsing error");
                        }

                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }

                        currentNode = WrapFunction(currentNode, predenceLevel, false);
                    }
                    else if ((currentParseValue + token).ToUpper() == "ABS(")
                    {
                        currentNode = new Absolute(predenceLevel).AttachNode(currentNode);

                        predenceLevel += MAX_PREDENCE + 1;
                    }
                    else if ((currentParseValue + token).ToUpper() == "ROUND(")
                    {
                        currentNode = new Round(predenceLevel).AttachNode(currentNode);

                        predenceLevel += MAX_PREDENCE + 1;
                    }
                    else if ((currentParseValue + token).ToUpper() == "INT(")
                    {
                        currentNode = new RoundDown(predenceLevel).AttachNode(currentNode);

                        predenceLevel += MAX_PREDENCE + 1;
                    }
                    else if ((currentParseValue + token).ToUpper() == "IIF(")
                    {
                        currentNode = new IfStatement(predenceLevel).AttachNode(currentNode);

                        predenceLevel += MAX_PREDENCE + 1;
                    }
                    else if ((currentParseValue + token).ToUpper() == "MAX(")
                    {
                        currentNode = new Max(predenceLevel).AttachNode(currentNode);

                        predenceLevel += MAX_PREDENCE + 1;
                    }
                    else if ((currentParseValue + token).ToUpper() == "ISNAN(")
                    {
                        currentNode = new IsNaN(predenceLevel).AttachNode(currentNode);

                        predenceLevel += MAX_PREDENCE + 1;
                    }
                    else if ((currentParseValue + token).ToUpper() == "MIN(")
                    {
                        currentNode = new Min(predenceLevel).AttachNode(currentNode);

                        predenceLevel += MAX_PREDENCE + 1;
                    }
                    else if ((currentParseValue + token).ToUpper() == "AND")
                    {
                        if (currentParseValue.Length > 2)
                        {
                            currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 2));
                        }

                        currentNode = new And(predenceLevel).AttachNode(currentNode);
                    }
                    else if ((currentParseValue + token).ToUpper() == "OR")
                    {
                        if (currentParseValue.Length > 2)
                        {
                            currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 2));
                        }

                        currentNode = new Or(predenceLevel).AttachNode(currentNode);
                    }
                    else if ((currentParseValue + token).ToUpper() == "NOT")
                    {
                        if (currentParseValue.Length > 2)
                        {
                            currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 2));
                        }

                        currentNode = new Not(predenceLevel).AttachNode(currentNode);
                    }
                    else if (token == '(')
                    {
                        if (currentParseValue != "")
                        {
                            throw new Exception("Parsing error");
                        }

                        predenceLevel += MAX_PREDENCE + 1;
                    }
                    else if (token == ')')
                    {
                        if (predenceLevel == 0)
                        {
                            throw new Exception("Parsing error");
                        }

                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }

                        currentNode = WrapFunction(currentNode, predenceLevel, true);

                        predenceLevel -= MAX_PREDENCE + 1;
                    }
                    else if ((currentParseValue + token).EndsWith("="))
                    {
                        if (currentParseValue.Length > 1)
                        {
                            currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length));
                        }

                        currentNode = new Equal(predenceLevel).AttachNode(currentNode);
                    }
                    else if ((currentParseValue + token).EndsWith(">="))
                    {
                        if (currentParseValue.Length > 2)
                        {
                            currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 1));
                        }

                        currentNode = new EqualOrGreaterThan(predenceLevel).AttachNode(currentNode);
                    }
                    else if ((currentParseValue + token).EndsWith("<="))
                    {
                        if (currentParseValue.Length > 2)
                        {
                            currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 1));
                        }

                        currentNode = new EqualOrLessThan(predenceLevel).AttachNode(currentNode);
                    }
                    else if ((currentParseValue + token).EndsWith("<>"))
                    {
                        if (currentParseValue.Length > 2)
                        {
                            currentNode = AddValue(currentNode, currentParseValue.Substring(0, currentParseValue.Length - 1));
                        }

                        currentNode = new NotEqual(predenceLevel).AttachNode(currentNode);
                    }
                    else if (token == '>' && nextToken != '=')
                    {
                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }

                        currentNode = new GreaterThan(predenceLevel).AttachNode(currentNode);
                    }
                    else if (token == '<' && nextToken != '>' && nextToken != '=')
                    {
                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }

                        currentNode = new LessThan(predenceLevel).AttachNode(currentNode);
                    }
                    else if (token == '+')
                    {
                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }

                        currentNode = new Add(predenceLevel).AttachNode(currentNode);
                    }
                    else if (token == '-')
                    {
                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }

                        if (currentNode == null || currentNode is Operand || currentNode is Function)
                        {
                            currentNode = new Negate(predenceLevel).AttachNode(currentNode);
                        }
                        else
                        {
                            currentNode = new Subtract(predenceLevel).AttachNode(currentNode);
                        }
                    }
                    else if (token == '*')
                    {
                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }

                        currentNode = new Multiply(predenceLevel).AttachNode(currentNode);
                    }
                    else if (token == '/')
                    {
                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }

                        currentNode = new Divide(predenceLevel).AttachNode(currentNode);
                    }
                    else if (token == '^')
                    {
                        if (currentParseValue != "")
                        {
                            currentNode = AddValue(currentNode, currentParseValue);
                        }

                        currentNode = new PowerOf(predenceLevel).AttachNode(currentNode);
                    }
                    else
                    {
                        if (currentParseValue.StartsWith("[") && currentParseValue.EndsWith("]") && token == '[')
                        {
                            throw new Exception("Two variables declared in a row");
                        }

                        currentParseValue += token;
                        continue;
                    }

                    currentParseValue = "";
                }
            } catch (Exception exc) {
                throw new Exception(exc.Message + " at token: " + currentToken + " in row: " + index);
            }

            if (currentParseValue != "")
            {
                currentNode = AddValue(currentNode, currentParseValue);
            }

            if (predenceLevel != 0)
            {
                throw new Exception("Parsing error");
            }

            while (currentNode.Parent != null)
            {
                currentNode = currentNode.Parent;
            }

            _startNode = currentNode;
            _variables = new List <string>(_variables.Distinct());

            Test();
        }