public void IsValidTest()
{
var c = new ValidParentheses();
// example1
var target = "()";
var result = c.IsValid(target);
Assert.IsTrue(result);
// example2
target = "()[]{}";
result = c.IsValid(target);
Assert.IsTrue(result);
//example3
target = "(]";
result = c.IsValid(target);
Assert.IsFalse(result);
//example4
target = "([)]";
result = c.IsValid(target);
Assert.IsFalse(result);
//example5
target = "{[]}";
result = c.IsValid(target);
Assert.IsTrue(result);
}
public void IsValidParentheses()
{
ValidParentheses isValidParentheses = new ValidParentheses();
string sample = "((";
Assert.AreEqual(isValidParentheses.IsValid(sample), false);
sample = "(())";
Assert.AreEqual(isValidParentheses.IsValid(sample), true);
sample = "((])";
Assert.AreEqual(isValidParentheses.IsValid(sample), false);
sample = "([)]";
Assert.AreEqual(isValidParentheses.IsValid(sample), false);
}
public void Test()
{
var s1 = "{{{{{{";
var s2 = "(([]}))}";
var s3 = "(())[]{}";
var s4 = "(({[))]}";
var valid = new ValidParentheses();
Assert.False(valid.IsValid(s1));
Assert.False(valid.IsValid(s2));
Assert.True(valid.IsValid(s3));
Assert.False(valid.IsValid(s4));
}
public void IsValid(string input, bool expected)
{
var sut = new ValidParentheses();
var actual = sut.IsValid(input);
Assert.AreEqual(expected, actual);
}
public void DoesntTryToPopAnEmptyStack()
{
var vp = new ValidParentheses();
// Assert.False(vp.IsValid("]"));
Assert.False(vp.IsValid("){"));
}
public void ValidParenthesesTest(string input, bool expected)
{
var target = new ValidParentheses();
var actual = target.IsValid(input);
Assert.Equal(expected, actual);
}
public void TestAlgorithm(string s, bool expected)
{
var func = new ValidParentheses();
var actual = func.IsValid(s);
Assert.Equal(expected, actual);
}
public void TestMethod1(string s, bool expected)
{
// Arrange
ValidParentheses question = new ValidParentheses();
// Act
bool actual = question.IsValid(s);
// Assert
Assert.AreEqual(expected, actual);
}
public void IsValidParentheses()
{
ValidParentheses l = new ValidParentheses();
Assert.IsTrue(l.IsValid("()[]"));
Assert.IsTrue(l.IsValid("[({})]"));
Assert.IsTrue(l.IsValid("[({})]{}"));
Assert.IsTrue(l.IsValid(""));
Assert.IsFalse(l.IsValid("[[({})]"));
Assert.IsFalse(l.IsValid("([)[]"));
Assert.IsFalse(l.IsValid("([)]"));
Assert.IsFalse(l.IsValid("{[{]]}{}[]"));
}
private static void ValidParenthesesTest()
{
Console.WriteLine("\n3 Valid Parentheses question:");
ValidParentheses validParentheses = new ValidParentheses();
IList <string> testStrings = new List <string> {
"()",
"()[]{}",
"(]",
"([)]",
"{[]}"
};
foreach (string testString in testStrings)
{
Console.WriteLine("{0} -> {1}", testString, validParentheses.IsValid(testString));
}
}
public void IsValidTestCase8()
{
var input = "(";
ValidParentheses.IsValid(input).Should().BeFalse();
}
public void ValidParentheses_FromLeetCode(string input, bool expected)
{
var result = ValidParentheses.IsValid(input);
result.Should().Equals(expected);
}
public void SingleBracketTypeClosesCorrectly(string parens)
{
var vp = new ValidParentheses();
Assert.True(vp.IsValid(parens));
}
public void When_only_one_pair_Then_valid()
{
Assert.AreEqual(true, ValidParentheses.IsValid("()"));
}
public void When_without_end_Then_invalid()
{
Assert.AreEqual(false, ValidParentheses.IsValid("({)"));
}
public void When_single_end_Then_invalid()
{
Assert.AreEqual(false, ValidParentheses.IsValid(")"));
}
public void IsValidTestCase5()
{
var input = "{[]}";
ValidParentheses.IsValid(input).Should().BeTrue();
}
public void When_two_pair_Then_valid()
{
Assert.AreEqual(true, ValidParentheses.IsValid("(){}"));
}
public void BracketsCloseInCorrectOrder(string parens)
{
var vp = new ValidParentheses();
Assert.True(vp.IsValid(parens));
}
public void InputNullOrWhitespace_ReturnTrue(string input)
{
var result = _validParenthesis.IsValid(input);
Assert.True(result, $"{input} is a valid parenthesis expression");
}
public void When_pair_crossed_Then_invalid()
{
Assert.AreEqual(false, ValidParentheses.IsValid("({)}"));
}
public void When_pair_contain_in_Then_valid()
{
Assert.AreEqual(true, ValidParentheses.IsValid("([]){}"));
}
public void BracketsClosingInWrongOrderShouldReturnFalse(string parens)
{
var vp = new ValidParentheses();
Assert.False(vp.IsValid(parens));
}
