VoltScriptTesting.bss

%REM
	Copyright 2022-2023 HCL America, Inc.
	Licensed under the Apache License, Version 2.0 (the "License"); 
	you may not use this file except in compliance with the License. 
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, 
	software distributed under the License is distributed on an "AS IS" BASIS, 
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
	See the License for the specific language governing permissions and limitations under the License	
%END REM

%REM
	Library BaliUnit
	Created Mar 14, 2022 by Paul Withers/UK/PNPHCL
	Unit Testing Framework for Bali and LotusScript
%END REM
Option Public
Option Declare

%REM
	Type used to hold results of an individual unit test
%END REM
Type TestCase
	
	description As String
	outcome As String
	errorMsg As String
	errorStack As String

End Type

' Default location for writing reports
Const BASE_REPORT_LOC = |unit-test-reports/|



' Core unit testing suite
Class TestSuite
	
    '{{SETI_AUTHOR_CODE_Internal_Member_Init
	Public customBeforeAfter As AbstractCustomBeforeAfter
	Public displayName As String
	Public errors As Integer
	Public failures As Integer
	Public missingAssertions As Integer
	Public results List As TestCase
	Public runTime As String
	Public suppressReport As Boolean
	Public tests As Integer
	Public title As String
	Private description As String
	Private outputLoc As String
	Private outputFormat As String
	Private stTime As Double
	Private endTime As Double
	Private started As Boolean
	Private isDelegatedAssertion As Boolean
	Private hasTestRunner As Boolean
	Private testRunnerName As String
	'}}
	
	%REM
		Adds object containing custom beforeAll, beforeEach, afterEach and/or afterAll code.
		@param customBeforeAfter Containing before and after functions
		@return					Fluent
	%END REM
	Function addCustomBeforeAfter(customBeforeAfter As AbstractCustomBeforeAfter) As TestSuite
		'{{SETI_AUTHOR_CODE_addCustomBeforeAfter
		Set Me.customBeforeAfter = customBeforeAfter
		Set addCustomBeforeAfter = Me
		'}}
	End Function
	
	%REM
		Checks whether an assertion has been run yet and, if not, starts the timer
		and runs beforeAll if a BaliCustomBeforeAfter has been passed in.
	%END REM
	Sub checkStarted()
		'{{SETI_AUTHOR_CODE_checkStarted
		If (Not started) Then
			stTime = Timer
			started = True
			If (Not Me.customBeforeAfter Is Nothing) Then
				Me.customBeforeAfter.beforeAll
			End If
		End If
		'}}
	End Sub
	
	%REM
		Ends timer, triggers afterAll if a BaliCustomBeforeAfter has been passed in,
		and prints out the report.
	%END REM
	Sub completeReport()
		'{{SETI_AUTHOR_CODE_completeReport
		On Error GoTo trapError
		
		Call endTimer
		
		If (Not Me.customBeforeAfter Is Nothing) Then
			Me.customBeforeAfter.afterAll
		End If

		If suppressReport Then Exit Sub
		
		Call printSummary()
		
		If (Me.outputFormat = "HTML" Or Me.outputFormat = "BOTH") Then
			If (Not hasTestRunner) Then
				Me.title = Me.title & |-| & FormatTimeForOutput(Now)
			End If
		
			Dim testSuiteReport As New BaliTestSuiteReport(Me.outputLoc)
			Call testSuiteReport.printoutReport(Me)
		End If

	exitSub:		
		Exit Sub
		
	trapError:
		MsgBox |Error | & Error(Err) & | on line | & CStr(Erl)
		Resume exitSub
		'}}
	End Sub
	
	%REM
		Destructor.
	%END REM
	Sub Delete
		'{{SETI_AUTHOR_CODE_delete
		Call Me.completeReport()
		'}}
	End Sub
	
	%REM
		Adds a unique description for the next test.
		@param description		Proposed description
		@return					Fluent
	%END REM
	Function describe(description As String) As TestSuite
		'{{SETI_AUTHOR_CODE_describe
		Dim uniqueDesc As String
		uniqueDesc = makeDescriptionUnique(description)
		Me.description = uniqueDesc
		Me.tests = Me.tests + 1
		' Add placeholder in case no assertion is run
		Me.missingAssertions = Me.missingAssertions + 1
		Me.results(Me.description).description = Me.description
		Me.results(Me.description).outcome = |Failed|
		Me.results(Me.description).errorMsg = "No assertion"
		Set describe = Me
		'}}
	End Function
	
	%REM
		Duration of tests.
		@return					Time the test ran for in seconds, as a string
	%END REM
	Function duration As String
		'{{SETI_AUTHOR_CODE_duration
		Dim dur As Double
		dur = endTime - stTime
		duration = CStr(Round(dur, |0.01|))
		'}}
	End Function
	
	%REM
		Sets endTime to Timer.
	%END REM
	Sub endTimer
		'{{SETI_AUTHOR_CODE_endTimer
		endTime = Timer
		'}}
	End Sub

	%REM
		Converts error message to human readable format.
		@return					Human readable error description, number and line
	%END REM
	Function getErrorMsg As String
		'{{SETI_AUTHOR_CODE_getErrorMsg
		getErrorMsg = |Error | & Error & |(| & Err() & |) on line | & Erl
		'}}
	End Function
	
	%REM
		Getter for output format, default is HTML.
		@return					"HTML", "XML" or "BOTH"
	%END REM
	Function getOutputFormat() As String
		'{{SETI_AUTHOR_CODE_getOutputFormat
		getOutputFormat = outputFormat
		'}}
	End Function
	
	%REM
		Sets this test as included in a BaliTestRunner. Called by BaliTestRunner.addTestSuite.
		@param testRunnerName 	TestRunner name test is included in
		@returns				Fluent
	%END REM
	Function includeInTestRunner(testRunnerName As String) As TestSuite
		'{{SETI_AUTHOR_CODE_includeInTestRunner
		Me.hasTestRunner = True
		Me.testRunnerName = testRunnerName
		Set includeInTestRunner = Me
		'}}
	End Function
	
	%REM
		Constructor
		@param title 			Title for the report
	%END REM
	Sub New(title As String)
		'{{SETI_AUTHOR_CODE_constructor
		Me.title = title
		Me.errors = 0
		Me.failures = 0
		Me.tests = 0
		Me.missingAssertions = 0
		Me.outputFormat = "HTML"
		'}}
	End Sub
	
	%REM
		Sets a directory to write reports to, overriding default "unit-test-reports".
		@param outputLoc		Directory to write reports
		@return					Fluent
	%END REM
	Function outputTo(outputLoc As String) As TestSuite
		'{{SETI_AUTHOR_CODE_outputTo
		Dim lastChar As String
		lastChar = Right(FullTrim(outputLoc), 1)
		If (lastChar <> |\\| And lastChar <> |/|) Then
			outputLoc = outputLoc & |/|
		End If
		Me.outputLoc = outputLoc
		Set outputTo = Me
		'}}
	End Function
	
	%REM
		Whether there are errors, failures or missing assertions.
		@return					True if no errors, failures or missing assertions
	%END REM
	Function ranSuccessfully As Boolean
		'{{SETI_AUTHOR_CODE_ranSuccessfully
		If (Me.errors = 0 And Me.failures = 0 And Me.missingAssertions = 0) Then
			ranSuccessfully = True
		End If
		'}}
	End Function
	
	%REM
		Tests whether a AbstractBaliCustomBeforeAfter has been passed in and, if so, calls afterEach.
		Triggered automatically from all in-built assertiopns.
	%END REM
	Sub runAfterEach()
		'{{SETI_AUTHOR_CODE_runAfterEach
		If (Not Me.customBeforeAfter Is Nothing) Then
			Me.customBeforeAfter.afterEach
		End If
		'}}
	End Sub
	
	%REM
		Tests whether a AbstractBaliCustomBeforeAfter has been passed in and, if so, calls beforeEach.
	%END REM
	Sub runBeforeEach()
		'{{SETI_AUTHOR_CODE_runBeforeEach
		If (Not Me.customBeforeAfter Is Nothing) Then
			Me.customBeforeAfter.beforeEach
		End If
		'}}
	End Sub
	
	%REM
		Sets the display name to show in reports.
		@param displayName		A more readable explanation of the report. Used in XML output for Jenkins.
		@return					Fluent
	%END REM
	Public Function setDisplayName(displayName As String) As TestSuite
		'{{SETI_AUTHOR_CODE_setDisplayName
		Me.displayName = displayName
		Set setDisplayName = Me
		'}}
	End Function
	
	%REM
		Sets the output format for the reports.
		@param formatType 		Format for reports, "HTML", "XML" or "BOTH"
		@return					Fluent
		@throws Error 1400, invalid format type if formatType is not "HTML", "XML" or "BOTH"
	%END REM
	Function setOutputFormat(formatType As String) As TestSuite
		'{{SETI_AUTHOR_CODE_setOutputFormat
		Select Case formatType
			Case "HTML", "XML", "BOTH":
				
			Case Else
			Error 1400, "Invalid format type, only HTML, XML or BOTH are supported"
		End Select
		
		outputFormat = formatType
		Set setOutputFormat = Me
		'}}
	End Function
	
	
	%REM
		********************************************************
		START OF ASSERTIONS
		
		All assertions run beforeEach and afterEach, if required
		********************************************************
	%END REM
	
	%REM
		Tests whether the value passed is a boolean True and returns assertion outcome.
		@param actual			Value to be tested
		@return					Assertion outcome
	%END REM
	Function assertTrue(actual As Boolean) As Boolean
		'{{SETI_AUTHOR_CODE_assertTrue
		checkStarted
		
		' runBeforeEach will already have been called
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If
		
		If (actual) Then
			addResult True, ||
			assertTrue = True
		Else
			addResult False, |Expected: true, but was: false|
			assertTrue = False
		End If
		
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		'}}
	End Function
	
	%REM
		Tests whether the value passed is a boolean False.
		@param actual			Value to be tested
		@return					Assertion outcome
	%END REM
	Function assertFalse(actual As Boolean) As Boolean
		'{{SETI_AUTHOR_CODE_assertFalse
		checkStarted
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If
		
		If (Not actual) Then
			addResult True, ||
			assertFalse = True
		Else
			addResult False, |Expected: false, but was: true|
			assertFalse = True
		End If
		
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		'}}
	End Function
	
	%REM
		Tests whether two strings match, applying basic case sensitivity as required (LCase-ing expected and actual).
		@param expected			String to test against
		@param actual			String to test
		@param caseInsensitive	Whether to compare in current case or as lower case
		@return					Assertion outcome
	%END REM
	Function assertEqualsString(expected As String, actual As Variant, caseInsensitive As Boolean) As Boolean
		'{{SETI_AUTHOR_CODE_assertEqualsString
		checkStarted
		
		On Error GoTo errCatch
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If
	
		Dim expectedForReport As String, actualForReport As String
		Dim expectedForComparison As String, actualForComparison As String

		If (TypeName(expected) <> "STRING") Then
			addResult False, |Expected is not a String, instead is: | & TypeName(expected)
			assertEqualsString = False
			GoTo getOut
		ElseIf(TypeName(actual) <> "STRING") Then
			addResult False, |Actual is not a String, instead is: | & TypeName(actual)
			assertEqualsString = False
			GoTo getOut
		End If
	
		expectedForReport = expected
		actualForReport = actual
	
		If (caseInsensitive) Then
			expectedForComparison = LCase(expected)
			actualForComparison = LCase(actual)
		Else
			expectedForComparison = expected
			actualForComparison = actual
		End If
	
		If (expectedForComparison = actualForComparison) Then
			addResult True, ||
			assertEqualsString = True
		Else
			addResult False, |Expected: | & expectedForReport & | but was: | & actualForReport
			assertEqualsString = False
		End If
			
getOut:
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		Exit Function
			
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two strings do not match.
		@param expected			String to test against
		@param actual			String to test
		@return					Assertion outcome
	%END REM
	Function assertNotEqualString(expected As Variant, actual As Variant) As Boolean
		'{{SETI_AUTHOR_CODE_assertNotEqualString
		checkStarted
		
		On Error GoTo errCatch
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If
	
		If (TypeName(expected) <> "STRING") Then
			addResult False, |Expected is not a String, instead is: | & TypeName(expected)
			assertNotEqualString = False
			GoTo getOut
		ElseIf(TypeName(actual) <> "STRING") Then
			addResult False, |Actual is not a String, instead is: | & TypeName(actual)
			assertNotEqualString = False
			GoTo getOut
		End If

		If (expected <> actual) Then
			addResult True, ||
			assertNotEqualString = True
		Else
			addResult False, |Expected: | & expected & | matches actual: | & actual
			assertNotEqualString = False
		End If
		
getOut:
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		Exit Function
		
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two integers match.
		@param expected			Integer to test against
		@param actual			Integer to test
		@return					Assertion outcome
	%END REM
	Function assertEqualsInteger(expected As Integer, actual As Integer) As Boolean
		'{{SETI_AUTHOR_CODE_assertEqualsInteger
		checkStarted
		
		On Error GoTo errCatch
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If

		If (expected = actual) Then
			addResult True, ||
			assertEqualsInteger = True
		Else
			addResult False, |Expected: | & CStr(expected) & |, but was: | & CStr(actual)
			assertEqualsInteger = False
		End If	
		
getOut:
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		Exit Function
		
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two integers do not match.
		@param expected 		Integer to test against
		@param actual			Integer to test
		@return					Assertion outcome
	%END REM
	Function assertNotEqualInteger(expected As Integer, actual As Integer) As Boolean
		'{{SETI_AUTHOR_CODE_assertNotEqualInteger
		checkStarted
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If

		On Error GoTo errCatch
		
		If (expected <> actual) Then
			addResult True, ||
			assertNotEqualInteger = True
		Else
			addResult False, |Expected: | & CStr(expected) & | matches actual: | & CStr(actual)
			assertNotEqualInteger = False
		End If
		
		
getOut:
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		Exit Function
		
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two doubles match, CStr-ing expected and actual to avoid bit-level issues.
		@param expected 		Double to test against
		@param actual			Double to test
		@return					Assertion outcome
	%END REM
	Function assertEqualsDouble(expected As Double, actual As Double) As Boolean
		'{{SETI_AUTHOR_CODE_assertEqualsDouble
		checkStarted
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If

		On Error GoTo errCatch
		
		If (CStr(expected) = CStr(actual)) Then
			addResult True, ||
			assertEqualsDouble = True
		Else
			addResult False, |Expected: | & CStr(expected) & |, but was: | & CStr(actual)
			assertEqualsDouble = False
		End If	
		
getOut:
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		Exit Function
		
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two doubles do not match, CStr-ing to avoid false positives.
		@param expected			Double to test against
		@param actual			Double to test
		@return					Assertion outcome
	%END REM
	Function assertNotEqualDouble(expected As Double, actual As Double) As Boolean
		'{{SETI_AUTHOR_CODE_assertNotEqualDouble
		checkStarted
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If

		On Error GoTo errCatch
		
		If (CStr(expected) <> CStr(actual)) Then
			addResult True, ||
			assertNotEqualDouble = True
		Else
			addResult False, |Expected: | & CStr(expected) & | matches actual: | & CStr(actual)
			assertNotEqualDouble = False
		End If
		
getOut:
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		Exit Function
		
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether a double is between two bounds ("between", not "strictly between"). 
		Note, this cannot be a delegated assertion.
		@param expected1		Lower bound to test, the actual must be greater than or equal to this
		@param expected2		Upper bound to test, the actual must be less than or equal to this
		@param actual			Double to test
		@return					Assertion outcome
	%END REM
	Function assertIsBetween(expected1 As Double, expected2 As Double, actual As Double) As Boolean
		'{{SETI_AUTHOR_CODE_assertIsBetween
		checkStarted
		
		On Error GoTo errCatch
		
		runBeforeEach

		If (actual >= expected1 And actual <= expected2) Then
			addResult True, ||
			assertIsBetween = True
		Else
			addResult False, |Expected: Between | & CStr(expected1) & | and | & CStr(expected2) & |, but was: | & CStr(actual)
			assertIsBetween = False
		End If
			
getOut:
		runAfterEach
		Exit Function
		
errCatch:
		addError getErrorMsg(), ||
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether a double is NOT between two bounds ("between", not "strictly between"). 
		Note, this cannot be a delegated assertion.
		@param expected1 		Lower bound to test, the actual must be less than this
		@param expected2		Upper bound to test, the actual must be greater than this
		@param actual			Double to test
		@return					Assertion outcome
	%END REM
	Function assertIsNotBetween(expected1 As Double, expected2 As Double, actual As Double) As Boolean
		'{{SETI_AUTHOR_CODE_assertIsNotBetween
		checkStarted
		
		On Error GoTo errCatch
		
		runBeforeEach
	
		If (actual < expected1) Then
			addResult True, ||
			assertIsNotBetween = True
		ElseIf (actual > expected2) Then
			addResult True, ||
			assertIsNotBetween = True
		Else
			addResult False, |Expected: Not between | & CStr(expected1) & | and | & CStr(expected2) & |, but was: | & CStr(actual)
			assertIsNotBetween = False
		End If
			
getOut:
		runAfterEach
		Exit Function
			
errCatch:
		addError getErrorMsg(), ||
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether a double is greater than an expected value. Note, this cannot be a delegated assertion.
		@param expected 		Lower bound to test
		@param actual			Double to test
		@return					Assertion outcome
	%END REM
	Function assertIsGreaterThan(expected As Double, actual As Double) As Boolean
		'{{SETI_AUTHOR_CODE_assertIsGreaterThan
		checkStarted
		
		On Error goto errCatch
		
		runBeforeEach
	
		If (actual > expected) Then
			addResult True, ||
			assertIsGreaterThan = True
		Else
			addResult False, |Expected: Greater than | & CStr(expected) & |, but was: | & CStr(actual)
			assertIsGreaterThan = False
		End If
			
getOut:
		runAfterEach
		Exit Function
			
errCatch:
		addError getErrorMsg(), ||
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether a double is less than an expected value.
		@param expected			Upper bound to test
		@param actual			Double to test
		@return					Assertion outcome
	%END REM
	Function assertIsLessThan(expected As Double, actual As Double) As Boolean
		'{{SETI_AUTHOR_CODE_assertIsLessThan
		checkStarted
		
		On Error GoTo ErrCatch
		
		runBeforeEach
		
		If (actual < expected) Then
			addResult True, ||
			assertIsLessThan = True
		Else
			addResult False, |Expected: Greater than | & CStr(expected) & |, but was: | & CStr(actual)
			assertIsLessThan = False
		End If
		
getOut:
		runAfterEach
		Exit Function
		
errCatch:
		addError getErrorMsg(), ||
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two Longs match.
		@param expected			Long to test against
		@param actual			Long to test
		@return					Assertion outcome
	%END REM
	Function assertEqualsLong(expected As Long, actual As Long) As Boolean
		'{{SETI_AUTHOR_CODE_assertEqualsLong
		checkStarted

		On Error GoTo errCatch
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If

		If (expected = actual) Then
			addResult True, ||
			assertEqualsLong = True
		Else
			addResult False, |Expected: | & CStr(expected) & |, but was: | & CStr(actual)
			assertEqualsLong = False
		End If
		
getOut:
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		Exit Function
		
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two Longs do not match.
		@param expected			Long to test against
		@param actual 			Long to test
		@return					Assertion outcome
	%END REM
	Function assertNotEqualLong(expected As Long, actual As Long) As Boolean
		'{{SETI_AUTHOR_CODE_assertNotEqualLong
		checkStarted
		
		On Error GoTo errCatch
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If

		If (expected <> actual) Then
			addResult True, ||
			assertNotEqualLong = True
		Else
			addResult False, |Expected: | & CStr(expected) & | matches actual: | & CStr(actual)
			assertNotEqualLong = False
		End If
		
getOut:
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		Exit Function
		
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two Singles match.
		@param expected 		Single to test against
		@param actual			Single to test
		@return					Assertion outcome
	%END REM
	Function assertEqualsSingle(expected As Single, actual As Single) As Boolean
		'{{SETI_AUTHOR_CODE_assertEqualsSingle
		checkStarted
		
		On Error GoTo errCatch
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If

		If (CStr(expected) = CStr(actual)) Then
			addResult True, ||
			assertEqualsSingle = True
		Else
			addResult False, |Expected: | & CStr(expected) & |, but was: | & CStr(actual)
			assertEqualsSingle = False
		End If
		
getOut:
		If (Not Me.isDelegatedAssertion) Then
				runAfterEach
			End If
		Exit Function
		
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two Singles do not match.
		@param expected			Single to test against
		@param actual			Single to test
		@return					Assertion outcome
	%END REM
	Function assertNotEqualSingle(expected As Single, actual As Single) As Boolean
		'{{SETI_AUTHOR_CODE_assertNotEqualSingle
		checkStarted
		
		On Error GoTo errCatch
		
		If (Not Me.isDelegatedAssertion) Then
			runBeforeEach
		End If

		If (CStr(expected) <> CStr(actual)) Then
			addResult True, ||
			assertNotEqualSingle = True
		Else
			addResult False, |Expected: | & CStr(expected) & | matches actual: | & CStr(actual)
			assertNotEqualSingle = False
		End If
		
getOut:
		If (Not Me.isDelegatedAssertion) Then
			runAfterEach
		End If
		Exit Function
		
errCatch:
		If (Not Me.isDelegatedAssertion) Then
			addError getErrorMsg(), ||
		Else
			Error 1501, getErrorMsg()
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two numeric values match, converting them to double and calling assertEqualsDouble.
		@param expected			Numeric to test against
		@param actual			Numeric to test
		@return					Assertion outcome
	%END REM
	Function assertEqualsNumeric(expected As Variant, actual As Variant) As Boolean
		'{{SETI_AUTHOR_CODE_assertEqualsNumeric
		checkStarted
		
		On Error GoTo errCatch
		runBeforeEach
	
		If (Not IsNumeric(actual)) Then
			addResult False, |Actual is not numeric: | & CStr(actual)
			assertEqualsNumeric = False
		Else
			Me.isDelegatedAssertion = True
			assertEqualsNumeric = assertEqualsDouble(CDbl(expected), CDbl(actual))
			Me.isDelegatedAssertion = False
		End If
			
getOut:
		runAfterEach
		Exit Function
			
errCatch:
		addError Error(), ||
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests whether two numeric values do not match, converting them to double and calling assertNotEqualDouble.
		@param expected			Numeric to test against
		@param actual			Numeric to test
		@return					Assertion outcome
	%END REM
	Function assertNotEqualNumeric(expected As Variant, actual As Variant) As Boolean
		'{{SETI_AUTHOR_CODE_assertNotEqualNumeric
		checkStarted
		
		On Error GoTo errCatch
		
		runBeforeEach
	
		If (Not IsNumeric(actual)) Then
			addResult False, |Actual is not numeric: | & CStr(actual)
			assertNotEqualNumeric = False
		Else
			Me.isDelegatedAssertion = True
			assertNotEqualNumeric = assertNotEqualDouble(CDbl(expected), CDbl(actual))
			Me.isDelegatedAssertion = False
		End If
			
getOut:
		runAfterEach
		Exit Function
			
errCatch:
		addError Error(), ||
		Resume getOut
		'}}
	End Function
	
	
	%REM
		******************************************************
		TYPE COMPARISONS
		******************************************************
	%END REM
	
	%REM
		Tests whether a variant's type matches an expected type. Compares both type names as lower case.
		@param expectedType		Type name expected for actual object
		@param actual			Scalar or object to test
		@return					Assertion outcome
	%END REM
	Function assertIs(expectedType As String, actual As Variant) As Boolean
		'{{SETI_AUTHOR_CODE_assertIs
		checkStarted
		
		Dim actualType As String

		On Error GoTo errCatch
		runBeforeEach
	
		actualType = TypeName(actual)
		If (LCase(expectedType) = LCase(actualType)) Then
			addResult True, ||
			assertIs = True
		Else
			addResult False, |Expected: | & expectedType & |, but was: | & actualType
			assertIs = False
		End If
		
getOut:
		runAfterEach
		Exit Function
		
errCatch:
		addError getErrorMsg(), ||
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests that a variant's type does not match an expected type. Compares both type names as lower case.
		@param expectedType		Type name expected for actual object
		@param actual			Scalar or object to test
		@return					Assertion outcome
	%END REM
	Function assertIsNot(expectedType As String, actual As Variant) As Boolean
		'{{SETI_AUTHOR_CODE_assertIsNot
		checkStarted
		
		Dim actualType As String
		
		On Error GoTo errCatch
		
		runBeforeEach
	
		actualType = TypeName(actual)
		If (LCase(expectedType) <> LCase(actualType)) Then
			addResult True, ||
			assertIsNot = True
		Else
			addResult False, |Expected: | & expectedType & | matches actual: | & actualType
			assertIsNot = False
		End If
			
getOut:
		runAfterEach
		Exit Function
			
errCatch:
		addError getErrorMsg(), ||
		Resume getOut
		'}}
	End Function
	
	
	
	
	%REM
	****************************************************************
	START OF MULTI DATA-TYPE COMPARISONS
	****************************************************************
	%END REM
	
	%REM
		Tests two primitive variants are the same, ignoring data type and CStr-ing values.
		@param expected			Variant to test against
		@param actual			Variant to test
		@return					Assertion outcome
	%END REM
	Function assertEqualsPrimitive(expected As Variant, actual As Variant) As Boolean
		'{{SETI_AUTHOR_CODE_assertEqualsPrimitive
		checkStarted
		
		Dim typeExpected As String
		
		On Error GoTo errCatch
		
		typeExpected = TypeName(expected)
		Select Case typeExpected
			Case "STRING"
				assertEqualsPrimitive = assertEqualsString(CStr(Expected), CStr(Actual), False)
			Case "BOOLEAN"
				If (CBool(expected)) Then
					assertEqualsPrimitive = assertTrue(CBool(actual))
				Else
					assertEqualsPrimitive = assertFalse(CBool(actual))
				End If
			Case "DOUBLE"
				assertEqualsPrimitive = assertEqualsDouble(CDbl(Expected), CDbl(Actual))
			Case "INTEGER"
				assertEqualsPrimitive = assertEqualsInteger(CInt(Expected), CInt(Actual))
			Case "LONG"
				assertEqualsPrimitive = assertEqualsLong(CLng(Expected), CLng(Actual))
			Case "SINGLE"
				assertEqualsPrimitive = assertEqualsSingle(CSng(Expected), CSng(Actual))
			Case "DATE"
				assertEqualsPrimitive = assertEqualsDouble(CDbl(CDat(Expected)), CDbl(CDat(actual)))
			Case "CURRENCY"
				assertEqualsPrimitive = assertEqualsDouble(CDbl(Expected), CDbl(Actual))
			Case "BYTE"
				assertEqualsPrimitive = assertEqualsDouble(CDbl(Expected), CDbl(Actual))
			Case Else
				addResult False, |Unexpected data types, expected is a: | & typeExpected & _
				|, actual is a: | & TypeName(actual)
		End Select
			
getOut:
		Exit Function
			
errCatch:
		If (Err() = 13) Then
			addResult False, |Type mismatch between expected : | & CStr(expected) & | and actual: | & CStr(actual)
		Else
			addError Error(), ||
		End If
		Resume getOut
		'}}
	End Function
	
	%REM
		Tests two variants or variant arrays are the same.
		@param expected			Variant to test against
		@param actual			Variant to test
		@return					Assertion outcome
	%END REM
	Function assertEqualsPrimitiveOrPrimitiveArray(expected As Variant, actual As Variant) As Boolean
		'{{SETI_AUTHOR_CODE_assertEqualsPrimitiveOrPrimitiveArray
		checkStarted
		
		Dim areArrays As Boolean, result As Boolean
		
		If (testArrays(expected, actual, areArrays)) Then
			If (areArrays) Then
				result = processArray(Expected, Actual)
			Else
				result = assertEqualsPrimitive(expected, actual)
			End If
		End If
		
		assertEqualsPrimitiveOrPrimitiveArray = result
		'}}
	End Function
	
	%REM
		Compares two variants or variant arrays and tests they are not the same.
		@param expected			Variant to test against
		@param actual			Variant to test
		@return					Assertion outcome
	%END REM
	Function assertNotEqualPrimitiveOrPrimitiveArray(expected As Variant, actual As Variant) As Boolean
		'{{SETI_AUTHOR_CODE_assertNotEqualPrimitiveOrPrimitiveArray
		Dim i As Integer
		Dim result As Boolean
		
		checkStarted
		result = False
		
		On Error GoTo errCatch
		
		If (TypeName(expected) <> TypeName(actual)) Then
			addResult True, ||
			result = True
		Else
			If (Not IsArray(expected) And Not IsArray(actual)) Then
				If (CStr(expected) <> CStr(actual)) Then
					addResult True, ||
					result = True
				Else
					addResult False, |Expected: | & expected & | matches actual: | & actual
					result = False
				End If
			Else
				If (Not IsArray(expected) Or Not IsArray(actual)) Then
					addResult True, ||
					result = True
				ElseIf (UBound(expected) <> UBound(actual)) Then
					addResult True, ||
					result = True
				Else
					For i = 0 To UBound(expected)
						If (CStr(expected(i)) <> CStr(actual(i))) Then
							result = True
						End If
					Next
					If (result) Then
						addResult True, ||
					Else
						addResult False, |Expected: [| & Join(expected, |,|) & |] matches actual: [| & Join(actual, |,|) & |]|
					End If
				End If
			End If
		End If
	
		assertNotEqualPrimitiveOrPrimitiveArray = result
			
getOut:
		Exit Function
			
errCatch:
		addError getErrorMsg, ||
		Resume getOut
		'}}
	End Function
	
	
	%REM
		******************************************************
		FUNCTIONS FOR ADDING TO RESULTS LIST
		******************************************************
	%END REM
	
	%REM
		Adds a test success or failure to the results.
		@param success			Whether the test was successful or not
		@param failMessage		A message to write to explain the failure
	%END REM
	Sub addResult(success As Boolean, failMessage As String)
		'{{SETI_AUTHOR_CODE_addResult
		If (|| = FullTrim(Me.Description)) Then
			Me.tests = Me.tests + 1
			Me.description = |Test | & CStr(Me.tests)
		Else
			Me.missingAssertions = Me.missingAssertions - 1
		End If
		Me.results(Me.description).description = Me.description
		If (success) Then
			Me.results(Me.description).outcome = |Passed|
			Me.results(Me.description).errorMsg = ||
		Else
			Me.results(Me.description).outcome = |Failed|
			Me.results(Me.description).errorMsg = failMessage
			Me.failures = Me.failures + 1
		End If
		Me.description = ""
		'}}
	End Sub
	
	
	%REM
		Adds a test error to the results.
		@param errorMsg			A message to explain the error
		@param errorStack		More detailed stack for the error
	%END REM
	Sub addError(errorMsg As String, errorStack As Variant)
		'{{SETI_AUTHOR_CODE_addError
		If (|| = FullTrim(Me.Description)) Then
			Me.tests = Me.tests + 1
			Me.description = |Test | & CStr(Me.tests)
		Else
			Me.missingAssertions = Me.missingAssertions - 1
		End If
		Me.results(Me.description).description = Me.description
		Me.results(Me.description).outcome = |Error|
		Me.results(Me.description).errorMsg = errorMsg
		Me.results(Me.description).errorStack = convertErrorStack(errorStack)
		Me.errors = Me.errors + 1
		Me.description = ""
		'}}
	End Sub
	
    '*********************************************************************
    '*
    '* Internal Method Definitions
    '*
    '*********************************************************************
    '{{SETI_AUTHOR_CODE_Internal Methods
	
	%REM
		Adds a test failure and message to error stack to the results
		@param failMessage		A message to explain the error
		@param errorStack		More detailed stack for the error
	%END REM
	Private Sub addArrayFailure(failMessage As String, errorStack As Variant)
		If (|| = FullTrim(Me.Description)) Then
			Me.tests = Me.tests + 1
			Me.description = |Test | & CStr(Me.tests)
		End If
		Me.results(Me.description).description = Me.description
		Me.results(Me.description).outcome = |Failed|
		Me.results(Me.description).errorMsg = failMessage
		Me.results(Me.description).errorStack = convertErrorStack(errorStack)
		Me.failures = Me.failures + 1
		Me.description = ""
	End Sub
	
	%REM
		Converts a variant / variant array of errors to a string with HTML line breaks
		@param errorStack 		Variant or variant array of error stacks
		@return					String with HTML line breaks separating each element
	%END REM
	Private Function convertErrorStack(errorStack As Variant) As String
		
		Dim returnVal As String
		Dim i As Integer
		
		If (Not IsArray(errorStack)) Then
			returnVal = CStr(errorStack)
		Else
			For i = 0 To UBound(errorStack)
				If (returnVal <> "") Then
					returnVal = returnVal & |<br/>|
				End If
				returnVal = returnVal & errorStack(i)
			Next
		End If
		
		convertErrorStack = returnVal
		
	End Function
	
	%REM
		Private function to ensure proposed description is unique
		@param description		Proposed description
	%END REM
	Private Function makeDescriptionUnique(description) As String
		Dim newDesc As String
		Dim i As Integer
		
		newDesc = description
		i = 1
		While (IsElement(Me.results(newDesc)))
			newDesc = description & |_| & CStr(i)
			i = i + 1
		Wend
		
		makeDescriptionUnique = newDesc
	End Function

	%REM
		Prints a summary of tests run, errors and failures
	%END REM
	Private Sub printSummary()
		Dim prefix As String
		Dim altTitle As String * 40
		Dim msg As String

		If (hasTestRunner) Then
			prefix = Me.testRunnerName & ", "
		End If
		msg = |Ran | & prefix
		If (Len(Me.title) > 40) Then
			msg = msg & Me.title & " "
		Else
			altTitle = title
			msg = msg & altTitle
		End If
		Print msg & |: Tests | & Format(Me.tests,"@@") & |, Errors | & Format(Me.errors,"@@") &_
			 |, failures | & Format(Me.failures,"@@")  & |, missing assertions | & Format(Me.missingAssertions,"@@")
		'}}
	End Sub
	
	%REM
		Tests two arrays, testing each element matches. Called from assertEqualsPrimitiveOrPrimitiveArray 
		once both variants have been validated as arrays.
		@param expected			Variant array to test against
		@param actual			Variant array to test
		@return					Assertion outcome
	%END REM
	Private Function processArray(expected As Variant, actual As Variant) As Boolean
		Dim success As Boolean
		Dim errorStack() As String
		Dim tmpDescription As String
		Dim tmpErrMsg As String
		Dim tmpErrors As Integer, tmpFailures As Integer, tmpTests As Integer, i As Integer, j As Integer
		Dim tmpMissingAssertions As Integer
		
		' Testing each element in the array will increment errors and failure
		' We will need to reset them and manually increment afterwards
		success = True
		tmpErrors = Me.errors
		tmpFailures = Me.failures
		tmpTests = Me.tests
		tmpMissingAssertions = Me.missingAssertions

		tmpDescription = Me.description
		j = 0

		checkStarted

		On Error GoTo errCatch

		runBeforeEach
	
		Me.isDelegatedAssertion = True
		For i = 0 To UBound(expected)
			If Not runAssertionOnArrayElem(expected(i), actual(i), i, tmpErrMsg) Then
				success = False
				ReDim Preserve errorStack(j)
				If (j = 5) Then
					errorStack(j) = |...and others|
					Me.description = tmpDescription	'Adding will have cleared the error
					Me.tests = tmpTests
					Exit For
				End If
				errorStack(j) = tmpErrMsg
				j = j + 1
			End If
			Me.description = tmpDescription	'Adding will have cleared the error
			Me.tests = tmpTests
		Next
		Me.isDelegatedAssertion = False
	
		Me.missingAssertions = tmpMissingAssertions - 1
		If (Not success) Then
			addArrayFailure |Expected: [| & Join(expected) & |], but was: [| & Join(actual) & |]|, errorStack

			If (me.errors > tmpErrors) Then
				me.errors = tmpErrors + 1
			End If
			If (me.failures > tmpFailures) Then
				me.failures = tmpFailures + 1
			End If
		End If
		
		processArray = success
			
getOut:
		runAfterEach
		Exit Function
			
errCatch:
		addError getErrorMsg, ||
		Resume getOut
	End Function
	
	%REM
		Function runAssertionOnArrayElem
		Description: Comments for Function
	%END REM
	Function runAssertionOnArrayElem(expected As Variant, actual As Variant, i As Integer, errMsg As String) As Boolean
		On Error GoTo errCatch
		
		If (assertEqualsPrimitive(expected, actual)) Then
			runAssertionOnArrayElem = True
		Else
			runAssertionOnArrayElem = False
			Error 1400, |Element | & CStr(i + 1) & |: Expected: | & CStr(expected) & |, but was: | & CStr(actual)
		End If
					
getOut:
		Exit Function
errCatch:
		errMsg = getErrorMsg()
		Resume getOut
	End Function
	
	%REM
		Tests whether two variants are both arrays.
		@param expected			Variant to test is an array
		@param actual			Variant to test is array
		@param returnArrays		Whether or not both are arrays
		@returns				Whether the testing generated an error or not
	%END REM
	Private Function testArrays(expected As Variant, actual As Variant, returnArrays As Boolean) As Boolean

		Dim expectedIsArray As Boolean, actualIsArray As Boolean
		Dim errMsg As String
		Dim success As Boolean

		On Error GoTo errCatch
		
		If (IsArray(expected)) Then
			expectedIsArray = True
		End If
	
		If (IsArray(actual)) Then
			actualIsArray = True
		End If
	
		If (expectedIsArray <> actualIsArray) Then
			errMsg = |Invalid array comparison - expected is |
			If expectedIsArray Then
				errMsg = errMsg & | an array, actual is |
			Else
				errMsg = errMsg & | not an array, actual is |
			End If
			If actualIsArray Then
				errMsg = errMsg & | an array|
			Else
				errMsg = errMsg & | not an array|
			End If
			addResult False, errMsg
		Else
			If (Not expectedIsArray) Then
				success = True
			Else
				returnArrays = True	'We have two arrays
				If (UBound(expected) <> UBound(actual)) Then
					errMsg = |Elements in arrays not equal, expected: | & CStr(UBound(expected) + 1) & _
					|, actual: | & CStr(UBound(actual) + 1)
					addResult False, errMsg
				Else
					returnArrays = True
					success = True
				End If
			End If
		End If
			
getOut:
		testArrays = success
		Exit Function
			
errCatch:
		addError getErrorMsg(), ||
		resume getOut
	End Function

	'}}

End Class


' Class for the HTML report for a BaliTestSuite
Class BaliTestSuiteReport
	
    '{{SETI_AUTHOR_CODE_Internal_Member_Init
	Private htmlHead As String
	Private htmlIntro As String
	Private htmlOutro As String
	Private reportLoc As String
	'}}
	
	%REM
		Constructor
		@param outputLoc		Directory to write the HTML or XML report to
	%END REM
	Sub New(outputLoc As String)
		'{{SETI_AUTHOR_CODE_constructor
		If (outputLoc = ||) Then
			Me.reportLoc = BASE_REPORT_LOC
		Else
			Me.reportLoc = outputLoc
		End If
		
		htmlHead = |<html>
  <head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <style>
body {
  font-family: arial, sans-serif;
}
table {
  border-collapse: collapse;
  width: 100%;
}

td, th {
  border: 1px solid #dddddd;
  text-align: left;
  padding: 8px;
}

tr:nth-child(even) {
  background-color: #dddddd;
}

.overall {
  margin-bottom: 5px;
}
.overall::before {
  display: table;
  content: "";
}
.overall::after {
  display: table;
  content: "";
}

.container {
  margin: 0 auto;
  max-width: 1170px;
  padding-left: 15px;
  padding-right: 15px;
}

.row {
  margin-bottom: 15px;
  margin-left: -15px;
  margin-right: -15px;
}

.overall-passed {
  background-color: #009933;
}

.overall div {
  width:33.33333333%;
  float:left;
}

.overall-failed {
  background-color: #cc3300;
}

.tests {
  margin-left: -15px;
  margin-right: -15px;
}

.tests .summary {
  width: 49%;
  padding-right: 5px;
  float:left;
}

.tests .details {
  width: 50%;
  float:left;
}

.passed {
  color: #009933;
  cursor: pointer;
}
.passed::before {
  content: '\2713'; /* tick */
}

.failed {
  color: #003399;
  cursor: pointer;
}
.failed::before {
  content: '\2716' /* cross */
}

.error {
  color: #cc3300;
  cursor: pointer;
}
.error::before {
  content: '\2716' /* cross */
}

.highlight {
  background-color: #3333cc;
  color: #ffffff;
}
    </style>
    <script>
      let elemCount = {{testsRun}};
      function toggle(elemNum) {
        for (let i = 1; i <= elemCount; i++) {
          let elem = document.getElementById("test" + i);
          elem.classList.remove("highlight");
          let elemDetail = document.getElementById("testDetail" + i);
          elemDetail.style = "display:none";
        }
        let highlightElem = document.getElementById("test" + elemNum);
        highlightElem.classList.add("highlight");
        let showElem = document.getElementById("testDetail" + elemNum);
        showElem.style = "display:block";
      }
    </script>
  </head>

|	' End of htmlHead
		
		htmlIntro = |<body>
    <div class="container">
    <div class="row">
      <h1>{{title}}</h1>
      <div>Finished after: {{duration}} seconds</div>
    </div>
    <div class="overall row">
      <div>Runs: {{testsRun}}</div>
      <div>Errors: {{testsError}}</div>
      <div>Fails: {{testsFail}}</div>
    </div>
    <br/>
    <div class="{{overall-result}} row">&nbsp;</div>

    <div class="tests">
|
		
		htmlOutro = |
    </div>
  </div>
  </body>
</html>|
	'}}
	End Sub
	
	%REM
		Write out the actual HTML report.
		@param testSuite		Test suite to write out
	%END REM
	Sub printoutReport(testSuite As TestSuite)
		'{{SETI_AUTHOR_CODE_printoutReport
		Dim fileName As String
		Dim fileNum As Integer
		Dim htmlHeadMod As String
		Dim htmlIntroMod As String
		Dim oldStrings(5) As String
		Dim newStrings(5) As String
		Dim nowTime As String
		Dim testHtml As String
		Dim testErrorHtml As String
		Dim testCount As Integer
		
		On Error GoTo trapError
		
		'Generate body HTML		
		testCount = 0
		testHtml = |<div class="summary">|
		testErrorHtml = |<div class="details">|
		
		ForAll testCase In testSuite.results
			testCount = testCount + 1
			testHtml = testHtml & |<div id="test| & CStr(testCount)
			testHtml = testHtml & |" class=| & testCase.outcome
			testHtml = testHtml & | onclick="toggle(| & CStr(testCount)
			testHtml = testHtml & |)">&nbsp;| &  testCase.description & |</div>|
			
			testErrorHtml = testErrorHtml & |<div id="testDetail| & CStr(testCount)
			testErrorHtml = testErrorHtml & |" style="display:none">|
			testErrorHtml = testErrorHtml & testCase.errorMsg
			If (testCase.ErrorStack <> ||) Then
				testErrorHtml = testErrorHtml & |<br/><br/>Stack:<br/>| & testCase.errorStack
			End If
			testErrorHtml = testErrorHtml & |</div>|
		End ForAll
		
		testHtml = testHtml & |</div>|
		testErrorHtml = testErrorHtml & |</div>|
		
		' Get replace strings
		oldStrings(0) = |{{title}}|
		oldStrings(1)= |{{overall-result}}| 
		oldStrings(2) = |{{testsRun}}|
		oldStrings(3) = |{{testsFail}}|
		oldStrings(4) = |{{testsError}}|
		oldStrings(5) = |{{duration}}|
		
		newStrings(0) = testSuite.title
		If (testSuite.errors = 0 And testSuite.failures = 0 And testSuite.missingAssertions = 0) Then
			newStrings(1) = "overall-passed"
		Else
			newStrings(1) = "overall-failed"
		End If
		newStrings(2) = CStr(testCount)
		newStrings(3) = CStr(testSuite.failures)
		newStrings(4) = CStr(testSuite.errors)
		newStrings(5) = testSuite.duration()
		
		'Open file and run
		fileNum = FreeFile
		fileName = Me.reportLoc
		Call MakeDirsBaliUnit(fileName)
		fileName = fileName & Replace(testSuite.title, | |, ||) & |.html|
		Open filename For Output As filenum
		
		htmlHeadMod = Replace(htmlHead, |{{testsRun}}|, CStr(testCount))
		Print #filenum, htmlHeadMod
		
		htmlIntroMod = Replace(htmlIntro, oldStrings, newStrings)
		Print #fileNum, htmlIntroMod
		
		Print #fileNum, testHtml
		Print #fileNum, testErrorHtml
		
		Print #filenum, htmlOutro
		Close filenum
exitSub:
		Exit Sub
		
trapError:
		MsgBox |Error | & Error(Err) & | on line | & CStr(Erl)
		Resume exitSub
		'}}
	End Sub

End Class


' Class for creating custom tests, e.g. for a specific LSX
Class AbstractCustomTester
	
    '{{SETI_AUTHOR_CODE_Internal_Member_Init
	Public testSuite As TestSuite
	'}}
	
	%REM
		Constructor
	%END REM
	Sub New
		'{{SETI_AUTHOR_CODE_constructor
		
		'}}
	End Sub
	
	%REM
		Loads a BaliTestSuite into the tester, in which to record test results.
		
		@param testSuite		BaliTestSuite in which to record results
		@return					Fluent
	%END REM
	Function addTestSuite(testSuite As TestSuite) As AbstractCustomTester
		'{{SETI_AUTHOR_CODE_addTestSuite
		Set Me.testSuite = testSuite
		Set addTestSuite = Me
		'}}
	End Function
	
	%REM
		Main function to run tests. Must be overridden.
	%END REM
	Function runTests As Boolean
		'{{SETI_AUTHOR_CODE_runTests
		Error 1501, |Not implemented|
		'}}
	End Function

End Class


%REM
	Class for custom beforeAll, beforeEach, afterEach and afterAll code
	
	beforeAll is automatically run during BaliTestSuite.isStarted() function.
	beforeEach is automatically run by core BaliTestSuite assertions, but must be manually run in custom assertion tests.
	afterEach is automatically run by core BaliTestSuite assertions, but must be manually run in custom assertion tests.
	afterAll is automatically run during BaliTestSuite.delete() function, at the end of the scope for the BaliTestSuite.
%END REM
Class AbstractCustomBeforeAfter
	
	%REM
		Code to run before each assertion.
	%END REM
	Sub beforeEach()
		'{{SETI_AUTHOR_CODE_beforeEach

		'}}
	End Sub
	
	%REM
		Code to run before any assertion starts.
	%END REM
	Sub beforeAll()
		'{{SETI_AUTHOR_CODE_beforeAll

		'}}
	End Sub
	
	%REM
		Code to run after each assertion is completed.
	%END REM
	Sub afterEach()
		'{{SETI_AUTHOR_CODE_afterEach

		'}}
	End Sub
	
	%REM
		Code to run after all assertions have completed.
	%END REM
	Sub afterAll()
		'{{SETI_AUTHOR_CODE_afterAll

		'}}
	End Sub

End Class


' Wrapper for outputting an index.html for multiple BaliTestSuites
Class TestRunner
	
    '{{SETI_AUTHOR_CODE_Internal_Member_Init
	Public testSuites List As TestSuite
	Private title As String
	Private nowTime As Variant
	Private htmlHead As String
	Private htmlIntro As String
	Private htmlOutro As String
	Private outputLoc As String
	Private engine As String
	Private outputFormat As String
	'}}
	
	%REM
		Adds a BaliTestSuite to this BaliTestRunner.
		@param testSuite		BaliTestSuite to add to this BaliTestRunner
	%END REM
	Sub addTestSuite(testSuite As TestSuite)
		'{{SETI_AUTHOR_CODE_addTestSuite
		Set me.testSuites(testSuite.title) = testSuite
		Call testSuite.includeInTestRunner(me.title).outputTo(getFilePath())
		'}}
	End Sub
	
	%REM
		Creates a new BaliTestSuite with a label and adds it to this BaliTestRunner.
		@param title			Title for the test suite
		@return					Created BaliTestSuite
	%END REM
	Function createTestSuite(title As String) As TestSuite
		'{{SETI_AUTHOR_CODE_createTestSuite
		Set me.testSuites(title) = New TestSuite(title)
		Set createTestSuite = me.testSuites(title)
		createTestSuite.includeInTestRunner(me.title).outputTo(Me.getFilePath())
		'}}
	End Function
	
	%REM
		Destructor. Prints out reports and erases test suites List.
	%END REM
	Sub Delete
		'{{SETI_AUTHOR_CODE_delete
		If (Me.outputFormat = "XML" Or Me.outputFormat = "BOTH") Then
			Call printoutXmlReport()
		End If
		If (Me.outputFormat = "HTML" Or Me.outputFormat = "BOTH") Then
			Call printoutReport()
		End If
		Erase testSuites
		'}}
	End Sub
	
	%REM
		Gets the directory to save the HTML / XML output to.
		@return					Directory to save to
	%END REM
	Function getFilePath() As String

		getFilePath = Me.outputLoc & Replace(Me.title, | |, ||) & "-" & Formattimeforoutput(Me.nowTime) & "/"

	End Function
	
	%REM
		Getter for output format, default is HTML
	%END REM
	Function getOutputFormat() As String
		'{{SETI_AUTHOR_CODE_getOutputFormat
		getOutputFormat = outputFormat
		'}}
	End Function
	
	%REM
		Constructor
		@param title			Title for the test run
	%END REM
	Sub New(title As String)
		'{{SETI_AUTHOR_CODE_constructor
		Me.outputLoc = BASE_REPORT_LOC
		Me.nowTime = Now
		Me.title = title
		Me.outputFormat = "HTML"
		
		Dim passedEngine As String
		passedEngine = Environ("TestRunnerEngine")
		If (passedEngine = "") Then
			engine = "baliunit-lotusscript"
		Else
			engine = passedEngine
		End If
		'}}
	End Sub
	
	%REM
		Sets a directory to write reports to.
		@param outputLoc		Directory to write reports
		@return					Fluent
	%END REM
	Function outputTo(outputLoc As String) As TestRunner
		'{{SETI_AUTHOR_CODE_outputTo
		Dim lastChar As String
		lastChar = Right(FullTrim(outputLoc), 1)
		If (lastChar <> |\\| And lastChar <> |/|) Then
			outputLoc = outputLoc & |/|
		End If
		Me.outputLoc = outputLoc
		Set outputTo = Me
		'}}
	End Function
	
	%REM
		Sets the output format for the reports
		@param formatType 		Format for reports, "HTML", "XML" or "BOTH"
		@return					Fluent
		@throws Error 1400, invalid format type if formatType is not "HTML", "XML" or "BOTH"
	%END REM
	Function setOutputFormat(formatType As String) As TestRunner
		'{{SETI_AUTHOR_CODE_setOutputFormat
		On Error GoTo 0
		Select Case formatType
			Case "HTML", "XML", "BOTH":
				
			Case Else
			Error 1400, "Invalid format type, only HTML, XML or BOTH are supported"
		End Select
		
		outputFormat = formatType
		Set setOutputFormat = Me
		'}}
	End Function
	
    '*********************************************************************
    '*
    '* Internal Method Definitions
    '*
    '*********************************************************************
    '{{SETI_AUTHOR_CODE_Internal Methods
	
	%REM
		Function getTestRunnerXml
		Description: Function to get testrunner level XML, including variable content
	%END REM
	Private Function getTestRunnerXml(tests As Integer, failures As Integer, errors As Integer) As String
		Dim runtime As String
		runTime = FormatTimeForOutput(Now)
		getTestRunnerXml = |<?xml version="1.0" encoding="UTF-8"?><testrun name="| & Me.title & |" | &_
		|tests="| & CStr(tests) & |" time="| & runtime & |" failures="| & CStr(failures) & |" errors="| & CStr(errors) & |">|
	End Function
	
	%REM
		Function cleanXmlString
		Description: Converts fouble quotes to single quotes
	%END REM
	Private Function cleanXmlString(inputStr As String) As String
		cleanXmlString = Replace(inputStr, |"|, |'|)
		cleanXmlString = Replace(cleanXmlString, |<|, |&lt;|)
		cleanXmlString = Replace(cleanXmlString, |>|, |&gt;|)
		cleanXmlString = Replace(cleanXmlString, |&|, |&amp;|)
	End Function
	
	%REM
		Prints out the HTML report
	%END REM
	Private Sub printoutReport
		'{{SETI_AUTHOR_CODE_printoutReport
		Dim fileName As String
		Dim fileNum As Integer
		Dim htmlHeadMod As String
		Dim htmlIntroMod As String
		Dim testCount As Integer
		Dim fileOpened As Boolean

		On Error GoTo trapError
		
		htmlHead = |<html>
  <head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <style>
body {
  font-family: arial, sans-serif;
}
table {
  border-collapse: collapse;
  width: 100%;
}

td, th {
  border: 1px solid #dddddd;
  text-align: left;
  padding: 8px;
}

tr:nth-child(even) {
  background-color: #dddddd;
}

.overall {
  margin-bottom: 5px;
}
.overall::before {
  display: table;
  content: "";
}
.overall::after {
  display: table;
  content: "";
}

.container {
  margin: 0 auto;
  max-width: 1170px;
  padding-left: 15px;
  padding-right: 15px;
}

.row {
  margin-bottom: 15px;
  margin-left: -15px;
  margin-right: -15px;
}

.overall-failed {
  background-color: #cc3300;
}

.summary {
  width: 20%;
  float:left;
  margin-right: 10px;
}

.body {
  width: 79%;
  float: left;
}

.passed {
  color: #009933;
  cursor: pointer;
}
.passed::before {
  content: '\2713'; /* tick */
}

.failed {
  color: #003399;
  cursor: pointer;
}
.failed::before {
  content: '\2716' /* cross */
}

.error {
  color: #cc3300;
  cursor: pointer;
}
.error::before {
  content: '\2716' /* cross */
}

.highlight {
  background-color: #3333cc;
  color: #ffffff;
}

iframe {
  width: 79%;
  height: 100%;
  border: 0px;
}
    </style>
    <script>
      let elemCount = {{testsRun}};
      function display(elemNum, title) {
        for (let i = 1; i <= elemCount; i++) {
          let elem = document.getElementById("test" + i);
          elem.classList.remove("highlight");
        }
        let highlightElem = document.getElementById("test" + elemNum);
        highlightElem.classList.add("highlight");
        let bodyElem = document.getElementById("bodyIframe");
        bodyElem.src = title;
      }
    </script>
  </head>

|	' End of htmlHead
		
		htmlIntro = |<body>
    <div class="container">
    <div class="summary">
|
		
		htmlOutro = |
    </div>
    <div class="body">
      <iframe src="" title="Test Results" id="bodyIframe"></iframe>
    </div>
  </div>
  </body>
</html>|
		
		'Open file and run
		fileNum = FreeFile
		fileName = Me.getFilePath()
		Call MakeDirsBaliUnit(Me.outputLoc)
		Call MakeDirsBaliUnit(fileName)
		Open fileName & |index.html| For Output As filenum
		fileOpened = True
		
		testCount = 0
		htmlIntroMod = htmlIntro
		ForAll test In testSuites
			testCount = testCount + 1
			Dim testClass As String
			Dim testFileName As String
			If (test.ranSuccessfully) Then
				testClass = "passed"
			ElseIf (test.errors > 0) Then
				testClass = "error"
			ElseIf (test.failures > 0) Then
				testClass="failed"
			ElseIf (test.missingAssertions > 0) Then
				testClass = "failed"
			End If
			htmlintroMod = htmlIntroMod & |<div class = "| & testClass & |" id="test| & CStr(testCount) & _
			|" onclick="display(| & CStr(testCount) & |,'| & Replace(test.title, " ", "") & |.html')">&nbsp;| &_
			 test.title & |</div>|
		End ForAll
		
		htmlHeadMod = Replace(htmlHead, |{{testsRun}}|, CStr(testCount))
		Print #filenum, htmlHeadMod
		
		Print #fileNum, htmlIntroMod
		
		Print #filenum, htmlOutro
exitSub:
		If (fileOpened) Then
			Close fileNum
		End If
		Exit Sub
		
trapError:
		MsgBox |Error | & Error(Err) & | on line | & CStr(Erl)
		Resume exitSub
		'}}
	End Sub
	
	%REM
		Prints out JUnit-compatible XML report
	%END REM
	Private Sub printoutXmlReport
		'{{SETI_AUTHOR_CODE_printoutXmlReport
		Dim fileName As String
		Dim fileNum As Integer
		Dim runTime As String
		Dim testCount As Integer, errorCount As Integer, failCount As Integer
		Dim fileOpened As Boolean
		Dim testTitle As String, testDisplayName As String, testDescription As String

		On Error GoTo trapError
		
		runTime = FormatTimeForOutput(Now)
		
		'Open file and run
		fileNum = FreeFile
		fileName = Me.getFilePath()
		Call MakeDirsBaliUnit(Me.outputLoc)
		Call MakeDirsBaliUnit(fileName)
		Open fileName & title & |.xml| For Output As filenum
		fileOpened = True
		
		testCount = 0
		errorCount = 0
		failCount = 0
		ForAll testsuite In testSuites
			Call testSuite.endTimer()
			testSuite.setOutputFormat(Me.outputFormat)
			testCount = testCount + testsuite.tests
			errorCount = errorCount + testsuite.errors
			failCount = failCount + testsuite.failures
		End ForAll
		
		Print #fileNum, getTestRunnerXml(testCount, failCount, errorCount)
		
		ForAll testsuite In testSuites
			testTitle = cleanXmlString(testSuite.title)
			If (testsuite.displayName = "") Then
				testdisplayName = testtitle
			Else
				testDisplayName = cleanXmlString(testsuite.displayName)
			End If
			Print #fileNum, |  <testsuite name="| & testTitle & |" time="| & testsuite.duration & |" displayname="| & testDisplayName &_
			|" id="[engine:| & Me.engine & |]/[| & testTitle & |]">|
			ForAll testCase In testsuite.results
				testDescription = cleanXmlString(testCase.description)
				Print #fileNum, |    <testcase name="| testDescription & |" classname="| & testTitle & |" time="0" displayname="| &_
				testDescription & |" id="[engine:| &_
				engine & |]/[| & testTitle & |]/[| & testDescription & |]">|
				Select Case testCase.outcome
				Case "Passed":
					Print #fileNum, |    </testcase>|
				Case "Failed":
					Print #fileNum, |      <failure>| & testCase.errorMsg
					If (testCase.ErrorStack <> ||) Then
						Print #fileNum, Replace(testCase.errorStack, "<br/>", Chr(10))
					End If
					Print #fileNum, |      </failure>
    </testcase>|
				Case "Error":
					Print #fileNum, |      <error>| & testCase.errorMsg
					If (testCase.ErrorStack <> ||) Then
						Print #fileNum, testCase.errorStack
					End If
					Print #fileNum, |      </error>
    </testcase>|
				End Select
				
			End ForAll
			
			Print #filenum, |  </testsuite>|
		End ForAll
		
		Print #fileNum, |</testrun>|
		
exitSub:
		If (fileOpened) Then
			Close fileNum
		End If
		Exit Sub
		
trapError:
		MsgBox |Error | & Error(Err) & | on line | & CStr(Erl)
		Resume exitSub
		'}}
	End Sub

	'}}
	
End Class

Private Function FormatTimeForOutput(dateVar As Variant) As String
	
	FormatTimeForOutput = Format(dateVar, |yymmddThhnnss|)
	
End Function
%REM
	Sub makeDirs
	Description: Function to make final directory, if required, or suppress error, if not required
%END REM
Private Sub makeDirsBaliUnit (path As String)
	
	On Error GoTo skipErr
	Dim fullPath As String
	
	fullPath = CurDir + "/" + path
	
	MkDir(fullPath)
	
	Exit Sub
	
skipErr:
	If (Err <> 75) Then
		MsgBox |Error | & Error(Err) & | on line | & CStr(Erl)
	End If
	Resume Next

End Sub