Ejemplo n.º 1
0
    def testMultiLineExpansionWithWrap(self):
		obj = TestConditionApprovedParser()
		lines = [ "TestMain.cpp:<line number>:",
					"PASSED:",
					"  CHECK( text.toString() == \" one two\n    three\n    four\" )",
					"with expansion:",
					"  \" one two",
					"      three",
					"      four\"",
					"  ==",
					"  \" one two",
					"      three",
					"      four\"",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		randomOutput = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 2
0
    def testFailedConditionSetsReason(self):
		obj = TestConditionApprovedParser()
		line = "ClassTests.cpp:<line number>: FAILED:"
		result = obj.parseApprovedLine(line)
		self.assertTrue(obj.current.reason == "FAILED")
		self.assertTrue(obj.current.filename == "ClassTests.cpp")
		self.assertTrue(obj.current.lineNumber == "line number")
Ejemplo n.º 3
0
    def testExceptionsExplicit(self):
		obj = TestConditionApprovedParser()
		lines = [ "ExceptionTests.cpp:<line number>: FAILED:",
					"  CHECK_THROWS_AS( thisThrows() )",
					"due to unexpected exception with message:",
					"  expected exception",
					"",
					"ExceptionTests.cpp:<line number>: FAILED:",
					"  CHECK_THROWS_AS( thisDoesntThrow() )",
					"because no exception was thrown where one was expected:",
					"",
					"ExceptionTests.cpp:<line number>: FAILED:",
					"  CHECK_NOTHROW( thisThrows() )",
					"due to unexpected exception with message:",
					"  expected exception",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 4
0
    def testExceptionsImplicit(self):
		obj = TestConditionApprovedParser()
		lines = [ "ExceptionTests.cpp:<line number>: FAILED:",
					"due to unexpected exception with message:",
					"  unexpected exception",
					"",
					"ExceptionTests.cpp:<line number>: FAILED:",
					"  {Unknown expression after the reported line}",
					"due to unexpected exception with message:",
					"  unexpected exception",
					"",
					"ExceptionTests.cpp:<line number>: FAILED:",
					"due to unexpected exception with message:",
					"  3.14",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 5
0
    def testConditionsWithoutExpansion(self):
		obj = TestConditionApprovedParser()
		lines = [ "ConditionTests.cpp:<line number>: FAILED:",
					"  CHECK( false != false )",
					"",
					"ConditionTests.cpp:<line number>: FAILED:",
					"  CHECK( true != true )",
					"",
					"ConditionTests.cpp:<line number>: FAILED:",
					"  CHECK( !true )",
					"with expansion:",
					"  false",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 6
0
    def testMultiLineExpansionWithTruncation(self):
		obj = TestConditionApprovedParser()
		lines = [ "TestMain.cpp:<line number>:",
					"PASSED:",
					"  CHECK_THAT( t.toString() EndsWith( \"... message truncated due to excessive size\" ) )",
					"with expansion:",
					"  \"***************************************************************************-",
					"  ***-",
					"  ****************************************************************************-",
					"  **-",
					"... message truncated due to excessive size",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 7
0
    def testTwoConditions(self):
		obj = TestConditionApprovedParser()
		lines = [ "ConditionTests.cpp:<line number>: FAILED:",
					"  CHECK( data.int_seven == 6 )",
					"with expansion:",
					"  7 == 6",
					"",
					"ConditionTests.cpp:<line number>: FAILED:",
					"  CHECK( data.int_seven == 8 )",
					"with expansion:",
					"  7 == 8",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 8
0
    def testMiscMessages(self):
		obj = TestConditionApprovedParser()
		lines = [ "MiscTests.cpp:<line number>: FAILED:",
					"  CHECK( ( fib[i] % 2 ) == 0 )",
					"with expansion:",
					"  1 == 0",
					"with message:",
					"  Testing if fib[0] (1) is even",
					"",
					"MiscTests.cpp:<line number>: FAILED:",
					"  CHECK( ( fib[i] % 2 ) == 0 )",
					"with expansion:",
					"  1 == 0",
					"with message:",
					"  Testing if fib[1] (1) is even",
					"",
					"MiscTests.cpp:<line number>: FAILED:",
					"  CHECK( ( fib[i] % 2 ) == 0 )",
					"with expansion:",
					"  1 == 0",
					"with message:",
					"  Testing if fib[3] (3) is even",
					"",
					"MiscTests.cpp:<line number>: FAILED:",
					"  CHECK( ( fib[i] % 2 ) == 0 )",
					"with expansion:",
					"  1 == 0",
					"with message:",
					"  Testing if fib[4] (5) is even",
					"",
					"MiscTests.cpp:<line number>: FAILED:",
					"  CHECK( ( fib[i] % 2 ) == 0 )",
					"with expansion:",
					"  1 == 0",
					"with message:",
					"  Testing if fib[6] (13) is even",
					"",
					"MiscTests.cpp:<line number>: FAILED:",
					"  CHECK( ( fib[i] % 2 ) == 0 )",
					"with expansion:",
					"  1 == 0",
					"with message:",
					"  Testing if fib[7] (21) is even",
					"",
					"Some information",
					"An error",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 9
0
    def testRandomOutput(self):
		obj = TestConditionApprovedParser()
		lines = [ "MiscTests.cpp:<line number>: FAILED:",
					"explicitly with message:",
					"  to infinity and beyond",
					"",
					"Message from section one",
					"Message from section two",
					"Some information",
					"An error",
					"Message from section one",
					"Message from section two",
					"Some information",
					"An error",
					"hello",
					"hello",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			try:
				result = obj.parseApprovedLine(line)
			except RandomOutput as e:
				randomOutput = e.output
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		self.assertTrue( len(randomOutput) == 10)
		newLines += randomOutput
		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 10
0
    def testExpansionConditionReturnsExpansion(self):
		obj = TestConditionApprovedParser()
		lines = ["ClassTests.cpp:<line number>: FAILED:",
					"  REQUIRE( s == \"world\" )",
					"with expansion:" ]
		for line in lines:
			result = obj.parseApprovedLine(line)
		self.assertTrue(result == None)
Ejemplo n.º 11
0
    def testFailedConditionSetsCondition(self):
		obj = TestConditionApprovedParser()
		lines = ["ClassTests.cpp:<line number>: FAILED:",
					"  REQUIRE( s == \"world\" )",
					""]
		for line in lines:
			result = obj.parseApprovedLine(line)
			self.assertTrue(result == None)
		
		self.assertTrue(obj.current.condition == "REQUIRE( s == \"world\" )")
		newLines = obj.current.generateApprovedLines()
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 12
0
    def testNoAssertions(self):
		obj = TestConditionApprovedParser()
		lines = [ "",
					"No assertions in test case './succeeding/exceptions/implicit'",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		randomOutput = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 13
0
    def testExpansionSetsExpansion(self):
		obj = TestConditionApprovedParser()
		lines = [ "ClassTests.cpp:<line number>: FAILED:",
					"  REQUIRE( s == \"world\" )",
					"with expansion:",
					"  1 == 2",
					"",
					"-------------------------------------------------------------------------------"
					]
		for line in lines:
			result = obj.parseApprovedLine(line)
		#print lines
		self.assertTrue(isinstance(result, TestConditionData))
		self.assertTrue(len(result.expansion) == 1)
		self.assertTrue(result.expansion[0] == "1 == 2")
		newLines = result.generateApprovedLines()
		newLines.append("-------------------------------------------------------------------------------")
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 14
0
    def testWarning(self):
		obj = TestConditionApprovedParser()
		lines = [ "MessageTests.cpp:<line number>:",
					"warning:",
					"  this is a warning",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 15
0
    def testMessagesExplicitFail(self):
		obj = TestConditionApprovedParser()
		lines = [ "MessageTests.cpp:<line number>: FAILED:",
					"explicitly with message:",
					"  This is a failure",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 16
0
    def testNoAssertionsWithOutput(self):
		obj = TestConditionApprovedParser()
		lines = [ "",
					"No assertions in section 'one'",
					"",
					"Message from section two",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		randomOutput = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 17
0
    def testMultiLineWarning(self):
		obj = TestConditionApprovedParser()
		lines = [ "TrickyTests.cpp:<line number>:",
					"warning:",
					"  Uncomment the code in this test to check that it gives a sensible compiler",
					"  error",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 18
0
    def testSuccessConditions(self):
		obj = TestConditionApprovedParser()
		lines = [ "ApproxTests.cpp:<line number>:",
					"PASSED:",
					"  REQUIRE( d == Approx( 1.23 ) )",
					"with expansion:",
					"  1.23 == Approx( 1.23 )",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print result
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 19
0
    def testMultiMessagesAfterCondition(self):
		obj = TestConditionApprovedParser()
		lines = [ "MiscTests.cpp:<line number>: FAILED:",
					"  REQUIRE( false )",
					"with messages:",
					"  hi",
					"  i := 7",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		randomOutput = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 20
0
    def testMultiLineExpansion(self):
		obj = TestConditionApprovedParser()
		lines = [ "MiscTests.cpp:<line number>:",
					"PASSED:",
					"  CHECK_THAT( testStringForMatching() AllOf( Catch::Contains( \"string\" ), Catch::Contains( \"abc\" ) ) )",
					"with expansion:",
					"  \"this string contains 'abc' as a substring\" ( contains: \"string\" and",
					"  contains: \"abc\" )",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		randomOutput = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 21
0
    def testFailedButOk(self):
		obj = TestConditionApprovedParser()
		lines = [ "MessageTests.cpp:<line number>:",
					"FAILED - but was ok:",
					"  CHECK_NOFAIL( 1 == 2 )",
					"",
					"",
					"No assertions in test case './succeeding/nofail'",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		randomOutput = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 22
0
    def testMessages1(self):
		obj = TestConditionApprovedParser()
		lines = [ "MessageTests.cpp:<line number>: FAILED:",
					"  REQUIRE( a == 1 )",
					"with expansion:",
					"  2 == 1",
					"with messages:",
					"  this message should be logged",
					"  so should this",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 23
0
    def testMultiMessages(self):
		obj = TestConditionApprovedParser()
		lines = [ "MessageTests.cpp:<line number>: FAILED:",
					"  REQUIRE( i < 10 )",
					"with expansion:",
					"  10 < 10",
					"with messages:",
					"  current counter 10",
					"  i := 10",
					"",
					"-------------------------------------------------------------------------------"
					]
		newLines = []
		for line in lines:
			result = obj.parseApprovedLine(line)
			if isinstance(result, TestConditionData):
				#print result
				newLines += result.generateApprovedLines()

		newLines.append("-------------------------------------------------------------------------------")
		#print lines
		#print newLines
		self.assertTrue( len(lines) == len(newLines) )
		self.assertTrue( lines == newLines )
Ejemplo n.º 24
0
    def testOtherConditionSetsFileNameAndLine(self):
		obj = TestConditionApprovedParser()
		line = "MessageTests.cpp:<line number>:"
		result = obj.parseApprovedLine(line)
		self.assertTrue(obj.current.filename == "MessageTests.cpp")
		self.assertTrue(obj.current.lineNumber == "line number")
Ejemplo n.º 25
0
	def __init__(self):
		self.state = self.NONE
		self.current = TestCaseData()
		self.conditionParser = TestConditionApprovedParser()
Ejemplo n.º 26
0
    def testEndOfTestCaseIsFound(self):
		obj = TestConditionApprovedParser()
		line = "-------------------------------------------------------------------------------"
		result = obj.parseApprovedLine(line)
		self.assertTrue(result == None)
		self.assertTrue(obj.current.empty())
Ejemplo n.º 27
0
    def testOtherConditionIsFound(self):
		obj = TestConditionApprovedParser()
		line = "ClassTests.cpp:<line number>:"
		result = obj.parseApprovedLine(line)
		self.assertTrue(result == None)
		self.assertTrue( not(obj.current.empty()) )
Ejemplo n.º 28
0
class TestCaseApprovedParser:
	NONE = 0
	TEST_CASE_NAME_EXPECTED = 1
	TEST_CASE_NAME = 2
	TEST_CLASS_EXPECTED = 3
	END_OF_CLASS_NAME_EXPECTED = 4
	TEST_CONDITION_EXPECTED = 5

	testFilenameParser = re.compile( r'(.*\..pp).*:<(.*).*>' )
	
	def __init__(self):
		self.state = self.NONE
		self.current = TestCaseData()
		self.conditionParser = TestConditionApprovedParser()

	def parseApprovedLine(self,line):
		result = None
		if self.state == self.NONE:
			if line.startswith("-------------------------------------------------------------------------------"):
				self.state = self.TEST_CASE_NAME_EXPECTED
			elif len(line):
				raise Exception("Unknown parse line: '" + line + "'")
		elif self.state == self.TEST_CASE_NAME_EXPECTED:
			if len(line):
				self.current.name = line.strip()
				self.current.nameParts.append(line.strip())
				self.state = self.TEST_CASE_NAME
			elif len(line):
				raise Exception("Unknown parse line: '" + line + "'")
		elif self.state == self.TEST_CASE_NAME:
			if line.startswith("-------------------------------------------------------------------------------"):
				self.state = self.TEST_CLASS_EXPECTED
			elif line.startswith("  "):
				#print "***SECTION: ",line
				self.current.sections.append(line[2:])
			elif len(line):
				if len(self.current.name) > 0:
					self.current.name += line.strip()
				else:
					self.current.name = line.strip()
				self.current.nameParts.append(line.strip())
		elif self.state == self.TEST_CLASS_EXPECTED:
			m = self.testFilenameParser.match(line)
			if m:
				self.current.filename = m.group(1).strip()
				self.current.lineNumber = m.group(2).strip()
				self.state = self.END_OF_CLASS_NAME_EXPECTED
			elif len(line):
				raise Exception("Unknown parse line: '" + line + "'")
		elif self.state == self.END_OF_CLASS_NAME_EXPECTED:
			if line.startswith("..............................................................................."):
				self.state = self.TEST_CONDITION_EXPECTED
			elif len(line):
				raise Exception("Unknown parse line: '" + line + "'")
		elif self.state == self.TEST_CONDITION_EXPECTED:
			#print "**** LINE " + line
			condition = self.conditionParser.parseApprovedLine(line)
			if isinstance(condition, TestConditionData):
				#print "**** CASE " + repr(condition)
				self.current.conditions.append(condition)
				if line.startswith("-------------------------------------------------------------------------------"):
					result = self.current
					self.current = TestCaseData()
					self.state = self.TEST_CASE_NAME_EXPECTED
				elif line.startswith("==============================================================================="):
					result = self.current
					self.current = TestCaseData()
					self.state = self.NONE

		return result