Flee - Fast Lightweight Expression Evaluator

Imports ciloci.Flee
Imports NUnit.Framework

Public Delegate Sub LineProcessor(ByVal line As String)

Friend Structure Mouse
	Public S As String
	Public I As Integer
	Public DT As DateTime
	Public Shared SharedDT As DateTime

	Public Sub New(ByVal s As String, ByVal i As Integer)
		Me.S = s
		Me.I = i
		DT = New DateTime(2007, 1, 1)
	End Sub

	Public Function GetI() As Integer
		Return I
	End Function

	Public Function GetYear(ByVal dt As DateTime) As Integer
		Return dt.Year
	End Function

	Default Public ReadOnly Property Item(ByVal i As Integer) As DateTime
		Get
			Return Me.DT
		End Get
	End Property
End Structure

Friend Class Monitor
	Public I As Integer
	Public S As String
	Public DT As DateTime
	Public Shared SharedString As String = "string"

	Public Sub New()
		I = 900
		S = "monitor"
		DT = New DateTime(2007, 1, 1)
	End Sub

	Public Function GetI() As Integer
		Return I
	End Function

	Default Public ReadOnly Property Item(ByVal i As Integer) As DateTime
		Get
			Return Me.DT
		End Get
	End Property
End Class

Friend Structure Keyboard
	Public StructA As Mouse
	Public ClassA As Monitor
End Structure

<Serializable()> _
Friend Class SerializableExpressionOwner

End Class

Friend Class ExpressionOwner
	Private DoubleA As Double
	Private SingleA As Single
	Private Int32A As Int32
	Private StringA As String
	Private BoolA As Boolean
	Private TypeA As Type
	Private ByteA As Byte
	Private ByteB As Byte
	Private SByteA As SByte
	Private Int16A As Int16
	Private UInt16A As UInt16
	Private IntArr As Integer() = {100, 200, 300}
	Private StringArr As String() = {"a", "b", "c"}
	Private DoubleArr As Double() = {1.1, 2.2, 3.3}
	Private BoolArr As Boolean() = {True, False, True}
	Private CharArr As Char() = {"."}
	Private DateTimeArr As DateTime() = {New DateTime(2007, 7, 1)}
	Private List As IList
	Private StringDict As System.Collections.Specialized.StringDictionary
	Private GuidA As Guid
	Private DateTimeA As DateTime
	Private ICloneableA As ICloneable
	Private ICollectionA As ICollection
	Private VersionA As System.Version
	Private StructA As TestStruct
	Private IComparableA As IComparable
	Private ObjectIntA As Object
	Private ObjectStringA As Object
	Private ValueTypeStructA As ValueType
	Private ExceptionA As Exception
	Private ExceptionNull As Exception
	Private IComparableString As IComparable
	Private IComparableNull As IComparable
	Private ICloneableArray As ICloneable
	Private DelegateANull As System.Delegate
	Private ArrayA As System.Array
	Private DelegateA As AppDomainInitializer
	Private AsciiEncodingArr As System.Text.ASCIIEncoding() = {}
	Private EncodingA As System.Text.Encoding
	Private KeyboardA As Keyboard
	Private DecimalA As Decimal
	Private DecimalB As Decimal

	Public Sub New()
		Me.DecimalA = 100
		Me.DecimalB = 0.25
		Me.KeyboardA = New Keyboard()
		Me.KeyboardA.StructA = New Mouse("mouse", 123)
		Me.KeyboardA.ClassA = New Monitor()
		Me.EncodingA = System.Text.Encoding.ASCII
		Me.DelegateA = AddressOf DoAction
		Me.ICloneableArray = New String() {}
		Me.ArrayA = New String() {}
		Me.DelegateANull = Nothing
		Me.IComparableNull = Nothing
		Me.IComparableString = "string"
		Me.ExceptionA = New ArgumentException
		Me.ExceptionNull = Nothing
		Me.ValueTypeStructA = New TestStruct
		Me.ObjectStringA = "string"
		Me.ObjectIntA = 100
		Me.IComparableA = 100.25
		Me.StructA = New TestStruct()
		Me.VersionA = New System.Version(1, 1, 1, 1)
		Me.ICloneableA = "abc"
		Me.GuidA = Guid.NewGuid()
		Me.List = New ArrayList()
		Me.List.Add("a")
		Me.List.Add(100)
		Me.StringDict = New Specialized.StringDictionary()
		Me.StringDict.Add("key", "value")
		Me.DoubleA = 100.25
		Me.SingleA = 100.25F
		Me.Int32A = 100000
		Me.StringA = "string"
		Me.BoolA = True
		Me.TypeA = GetType(String)
		Me.ByteA = 50
		Me.ByteB = 2
		Me.SByteA = -10
		Me.Int16A = -10
		Me.UInt16A = 100
		Me.DateTimeA = New DateTime(2007, 7, 1)
	End Sub

	Private Sub DoAction(ByVal args As String())

	End Sub

	Public Sub DoStuff()

	End Sub

	Public Function DoubleIt(ByVal i As Integer) As Integer
		Return i * 2
	End Function

	Public Function FuncString() As String
		Return "abc"
	End Function

	Public Shared Function SharedFuncInt() As Integer
		Return 100
	End Function

	Private Function PrivateFuncString() As String
		Return "abc"
	End Function

	Public Shared Function PrivateSharedFuncInt() As Integer
		Return 100
	End Function

	Public Function GetDateTime() As DateTime
		Return Me.DateTimeA
	End Function

	Public Function ThrowException() As Integer
		Throw New InvalidOperationException("Should not be thrown!")
	End Function

	Public ReadOnly Property DoubleAProp() As Double
		Get
			Return Me.DoubleA
		End Get
	End Property

	Private ReadOnly Property Int32AProp() As Int32
		Get
			Return Me.Int32A
		End Get
	End Property

	Friend Shared ReadOnly Property SharedPropA() As String
		Get
			Return "sharedprop"
		End Get
	End Property
End Class

Friend Structure TestStruct
	Implements IComparable

	Private MyA As Integer

	Public Function CompareTo(ByVal obj As Object) As Integer Implements System.IComparable.CompareTo

	End Function
End Structure

Friend MustInherit Class ExpressionTester

	Protected MyExpressionOwner As ExpressionOwner

	Public Sub New()
		MyExpressionOwner = New ExpressionOwner
	End Sub

	Public Overridable Sub ConfigureOptions(ByVal options As ExpressionOptions, ByVal arg As String)

	End Sub

	Public MustOverride Sub DoTest(ByVal e As Expression, ByVal result As String)
End Class

Friend Class ObjectExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedtype As Type = Type.GetType(result, True, True)
		Dim d As ExpressionEvaluator(Of Object) = e.Evaluator
		Dim expressionResult As Object = d()

		If expectedtype Is GetType(Void) Then
			Assert.IsNull(expressionResult)
		Else
			Assert.IsInstanceOfType(expectedtype, expressionResult)
		End If
	End Sub
End Class

Friend Class ByteExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As Byte = Byte.Parse(result)
		Dim d As ExpressionEvaluator(Of Byte) = e.Evaluator
		Assert.AreEqual(expectedResult, d())
	End Sub
End Class

Friend Class SByteExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As SByte = SByte.Parse(result)
		Dim d As ExpressionEvaluator(Of SByte) = e.Evaluator
		Assert.AreEqual(expectedResult, d())
	End Sub
End Class

Friend Class ShortExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As Short = Short.Parse(result)
		Dim d As ExpressionEvaluator(Of Short) = e.Evaluator
		Assert.AreEqual(expectedResult, d())
	End Sub
End Class

Friend Class UShortExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As UShort = UShort.Parse(result)
		Dim d As ExpressionEvaluator(Of UShort) = e.Evaluator
		Assert.AreEqual(expectedResult, d())
	End Sub
End Class

Friend Class IntegerExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As Integer = Integer.Parse(result)
		Dim d As ExpressionEvaluator(Of Integer) = e.Evaluator
		Assert.AreEqual(expectedResult, d())
	End Sub
End Class

Friend Class UnsignedIntegerExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As UInteger = UInteger.Parse(result)
		Dim d As ExpressionEvaluator(Of UInteger) = e.Evaluator
		Assert.AreEqual(expectedResult, d())
	End Sub
End Class

Friend Class Int64ExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As Int64 = Int64.Parse(result)
		Dim d As ExpressionEvaluator(Of Int64) = e.Evaluator
		Assert.AreEqual(expectedResult, d())
	End Sub
End Class

Friend Class UInt64ExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As UInt64 = UInt64.Parse(result)
		Dim d As ExpressionEvaluator(Of UInt64) = e.Evaluator
		Assert.AreEqual(expectedResult, d())
	End Sub
End Class

Friend Class DoubleExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As Double = Double.Parse(result)
		expectedResult = System.Math.Round(expectedResult, 4)
		Dim d As ExpressionEvaluator(Of Double) = e.Evaluator
		Dim expResult As Double = d()
		expResult = System.Math.Round(expResult, 4)
		Assert.AreEqual(expectedResult, expResult)
	End Sub
End Class

Friend Class SingleExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As Single = Single.Parse(result)
		expectedResult = System.Math.Round(expectedResult, 4)
		Dim d As ExpressionEvaluator(Of Single) = e.Evaluator
		Dim expResult As Single = d()
		expResult = System.Math.Round(expResult, 4)
		Assert.AreEqual(expectedResult, expResult)
	End Sub
End Class

Friend Class StringExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim d As ExpressionEvaluator(Of String) = e.Evaluator
		Dim expResult As String = d()
		Assert.AreEqual(result, expResult)
	End Sub
End Class

Friend Class BooleanExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As Boolean = Boolean.Parse(result)
		Dim d As ExpressionEvaluator(Of Boolean) = e.Evaluator
		Dim expResult As Boolean = d()
		Assert.AreEqual(expectedResult, expResult)
	End Sub
End Class

Friend Class CharExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As Char = Char.Parse(result)
		Dim d As ExpressionEvaluator(Of Char) = e.Evaluator
		Dim expResult As Char = d()
		Assert.AreEqual(expectedResult, expResult)
	End Sub
End Class

Friend Class DecimalExpressionTester
	Inherits ExpressionTester

	Public Overrides Sub DoTest(ByVal e As Expression, ByVal result As String)
		Dim expectedResult As Decimal = Decimal.Parse(result)
		Dim d As ExpressionEvaluator(Of Decimal) = e.Evaluator
		Dim expResult As Decimal = d()
		Assert.AreEqual(expectedResult, expResult)
	End Sub
End Class