public void Test10()
{
string a = ")((()";
//)((
Assert.AreEqual(false, Parentheses.ValidParentheses(a));
}
public void Test11()
{
string a = "((2=2))(((1 = 1)('a' = 'c'))(8 7 8))";
//
Assert.AreEqual(true, Parentheses.ValidParentheses(a));
}
public void Test7()
{
string a = "()())";
//)
Assert.AreEqual(false, Parentheses.ValidParentheses(a));
}
public void Test9()
{
string a = "(";
//(
Assert.AreEqual(false, Parentheses.ValidParentheses(a));
}
public void Test1()
{
string a = "(())((()())())";
//
Assert.AreEqual(true, Parentheses.ValidParentheses(a));
}
public void Test3()
{
string a = "))()(";
//))(
Assert.AreEqual(false, Parentheses.ValidParentheses(a));
}
public void TestMethodParenthesesFalse()
{
string s = "((1+3)((4+(3-5)))";
bool inBalance = false;
bool result = Parentheses.CheckParentheses(s);
Assert.AreEqual(inBalance, result);
}
public void Given_a_string_when_retrieve_then_return_the_length_of_the_longest_valid_parentheses(
string s, int expected)
{
var soution = new Parentheses();
var result = soution.LongestValidParentheses(s);
Assert.Equal(expected, result);
}
public void DeleteTwoOuterParentheses(string InputValue, string ExceptValue)
{
//Act
var rop = new Parentheses().RemoveOuterParentheses(InputValue);
//Assert
Assert.Equal(ExceptValue, rop);
}
public void TestParenthesesIsBalanced()
{
var list = new List <string> {
"((1+3)()(4+(3-5)))"
};
foreach (var s in list)
{
Assert.True(Parentheses.isBalanced(s));
}
}
public void Forest_Equal()
{
for (int i = 0; i < pars.Count; i++)
{
Forest p = new Parentheses(pars[i]);
Forest b = new LeftRight(lefts[i], rights[i]);
Forest np = new Parentheses(nPars[i]);
Forest nb = new LeftRight(nLefts[i], nRights[i]);
Assert.AreEqual(p, b);
Assert.AreNotEqual(np, nb);
}
}
public void TestParenthesesIsNotBalanced()
{
var list = new List <string>
{
"((())"
};
foreach (var s in list)
{
Assert.False(Parentheses.isBalanced(s));
}
}
public static Parentheses Parse(string input)
{
var tokens = new List <Token>();
foreach (var ch in input.StripChars(" \r\n"))
{
if (char.IsDigit(ch))
{
tokens.Add(new Number(ch - '0'));
}
else if (ch == '+')
{
tokens.Add(new Add());
}
else if (ch == '*')
{
tokens.Add(new Multiply());
}
else if (ch == '(')
{
tokens.Add(new ParentheseOpen());
}
else if (ch == ')')
{
tokens.Add(new ParentheseClose());
}
}
while (tokens.Any(t => t is ParentheseOpen || t is ParentheseClose))
{
var start = 0;
for (var pos = 0; pos < tokens.Count; pos++)
{
if (tokens[pos] is ParentheseOpen)
{
start = pos;
}
else if (tokens[pos] is ParentheseClose)
{
var elements = 1 + pos - start;
var operation = new Parentheses(tokens.Skip(start + 1).Take(elements - 2).ToArray());
tokens.RemoveRange(start, elements);
tokens.Insert(start, operation);
break;
}
}
}
return(new Parentheses(tokens.ToArray()));
}
IExpression ParsePrimitive()
{
var pos = CurrentPosition;
if (CurrentToken.Type == TokenType.NumberLiteral)
{
var lexeme = CurrentToken.Lexeme;
ReadNextToken();
return(ParseExpressionType(new Number(pos, lexeme)));
}
if (CurrentToken.Type == TokenType.StringLiteral)
{
var lexeme = CurrentToken.Lexeme;
ReadNextToken();
return(ParseExpressionType(new StringLiteral(pos, lexeme)));
}
if (CurrentToken.Type == TokenType.Identifier)
{
var lexeme = CurrentToken.Lexeme;
ReadNextToken();
return(ParseExpressionType(new Identifier(pos, lexeme)));
}
if (SkipIf("("))
{
var parentheses = new Parentheses(pos, ParseExpression());
Expect(")");
return(ParseExpressionType(parentheses));
}
if (SkipIf("["))
{
var elements = new List <IExpression>();
if (!SkipIf("]"))
{
elements.Add(ParseExpression());
while (SkipIf(","))
{
elements.Add(ParseExpression());
}
Expect("]");
}
return(new ArrayLiteral(pos, elements));
}
throw MakeError($"Ожидали идентификатор, число или открывающую скобку, получили {CurrentToken}");
}
IExpression ParsePrimitive()
{
var pos = CurrentPosition;
if (SkipIf("("))
{
var expression = new Parentheses(pos, ParseExpression());
Expect(")");
return(ParseExpressionType(expression));
}
if (IsType(TokenType.NumberLiteral))
{
var lexeme = CurrentToken.Lexeme;
ReadNextToken();
return(ParseExpressionType(new Number(pos, lexeme)));
}
if (IsType(TokenType.Identifier))
{
var lexeme = CurrentToken.Lexeme;
ReadNextToken();
return(ParseExpressionType(new Identifier(pos, lexeme)));
}
throw MakeError($"Ожидали идентификатор, число или скобку, получили {CurrentToken}");
}
void IExpressionVisitor.Visit(Parentheses This)
{
This.InnerExpression.AcceptVisitor(this);
}
public void When_StringContainsOpeningAndClosingBraces_Expect_IsValidAsFalse(string s, bool isValid)
{
Assert.True(Parentheses.IsValid(s) == isValid);
}
public bool Are_parens_paired_correctly(string input) => Parentheses.DoesEachParenHaveItsPair(input);
public void Correct_Null_ArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() => Parentheses.Correct(null));
}
public void SampleTest1()
{
Assert.AreEqual(true, Parentheses.ValidParentheses("()"));
}
public object VisitParentheses(Parentheses parentheses)
{
return(Calc(parentheses.Expr));
}
public void SampleTest2()
{
Assert.AreEqual(false, Parentheses.ValidParentheses(")(((("));
}
public static string GetParenthesesExpresstionType(Parentheses expression, VHDLCompilerInterface compiler)
{
return(GetExpressionType(expression.Expression, compiler));
}
public TypeRef VisitParentheses(Parentheses expression)
{
return(CompileExpression(expression.Expr));
}
public void VisitParentheses(Parentheses parentheses)
{
CompileExpression(parentheses.Expr);
}
public void ShouldReturnTrueWhenGivenValidStringOfPararentheses(string parentheses)
{
Assert.True(Parentheses.ValidParentheses(parentheses));
}
private Expression primary()
{
string text;
switch (lookahead)
{
case TokenType.PLACEHOLDER:
text = accept(TokenType.PLACEHOLDER);
int index;
try
{
index = Convert.ToInt32(text.Substring(1)) - 1;
}
catch (FormatException ex)
{
throw new ArgumentException("illegal placeholder " + text);
}
if (index < 0 || index > parameters.Count - 1)
{
throw new ArgumentException("illegal placeholder " + text);
}
return(parameters[index]);
case TokenType.LPAREN:
accept(TokenType.LPAREN);
Expression expr = new Parentheses(expression(0));
accept(TokenType.RPAREN);
return(expr);
case TokenType.DECIMAL_LITERAL:
text = accept(TokenType.DECIMAL_LITERAL);
return(new DecBasedInteger(text));
case TokenType.BASED_LITERAL:
text = accept(TokenType.BASED_LITERAL);
return(new BasedLiteral(text));
case TokenType.STRING_LITERAL:
text = accept(TokenType.STRING_LITERAL);
return(new StringLiteral(text.Substring(1, text.Length - 1)));
case TokenType.CHARACTER_LITERAL:
text = accept(TokenType.CHARACTER_LITERAL);
return(new CharacterLiteral(text[1]));
case TokenType.BINARY_BIT_STRING_LITERAL:
text = accept(TokenType.BINARY_BIT_STRING_LITERAL);
return(new BinaryStringLiteral(text.Substring(2, text.Length - 1)));
case TokenType.HEX_BIT_STRING_LITERAL:
text = accept(TokenType.HEX_BIT_STRING_LITERAL);
return(new HexStringLiteral(text.Substring(2, text.Length - 1)));
case TokenType.OCTAL_BIT_STRING_LITERAL:
text = accept(TokenType.OCTAL_BIT_STRING_LITERAL);
return(new OctalStringLiteral(text.Substring(2, text.Length - 1)));
default:
string errorToken = lookahead.ToString();
accept(lookahead);
throw new ArgumentException("illegal primary " + errorToken);
}
}
public void When_StringContainsOddLength_Expect_IsValidAsFalse(string s, bool isValid)
{
Assert.True(Parentheses.IsValid(s) == isValid);
}
public void ShouldReturnFalseWhenGivenInValidStringOfPararentheses(string parentheses)
{
Assert.False(Parentheses.ValidParentheses(parentheses));
}
public void When_StringIsEmpty_Expect_IsValidAsFalse(string s, bool isValid)
{
Assert.True(Parentheses.IsValid(s) == isValid);
}