Axiom.RenderSystems.OpenGL.ATI.PixelShader.RunTests C# (CSharp) Method

		public bool RunTests()
		{

			// ***TEST 1***
			// See if PositionToNextSymbol can find a valid symbol
			Console.WriteLine( "**Testing: PositionToNextSymbol\n" );

			source = testString1;
			charPos = 0;
			currentLine = 1;
			endOfSource = source.Length;
			while ( PositionToNextSymbol() )
			{
				Console.WriteLine( "  Character found: {0}   Line:{1}  : ", source[ charPos ], currentLine );
				if ( ( source[ charPos ] == test1results[ resultID ].character ) &&
					( currentLine == test1results[ resultID ].line ) )
				{
					Console.WriteLine( "Passed!" );
				}
				else
				{
					Console.WriteLine( "FAILED!" );
				}

				resultID++;
				charPos++;
			}

			Console.WriteLine( "**Finished testing: PositionToNextSymbol\n" );

			// ***TEST 2***
			// Did the type lib get initialized properly with a default name index
			Console.WriteLine( "**Testing: GetTypeDefText\n" );
			string resultStr = GetTypeDefText( Symbol.MOV );
			Console.WriteLine( " Default name of mov is {0}", resultStr );
			Console.WriteLine( "**Finished testing: GetTypeDefText\n" );

			// ***TEST 3***
			// Does IsSymbol work properly?
			Console.WriteLine( "**Testing: IsSymbol\n" );

			source = testString3;
			charPos = 0;
			Console.WriteLine( "  Before: {0}", source );
			Console.WriteLine( "  Symbol to find: {0}", testSymbols );

			if ( IsSymbol( testSymbols, out resultID ) )
			{
				Console.WriteLine( "  After: {0} : {1}", source.Substring( resultID + 1 ), ( source[ resultID + 1 ] == 'r' ) ? "Passed." : "Failed!" );
			}
			else
			{
				Console.WriteLine( "Failed!" );
			}

			Console.WriteLine( "  Symbol size: {0}", resultID );

			Console.WriteLine( "**Finished testing: IsSymbol\n" );

			// ***TEST 4***
			// Does IsFloatValue work properly?
			Console.WriteLine( "**Testing: IsFloatValue\n" );

			float val = 0;
			int charSize = 0;
			charPos = 0;

			for ( int i = 0; i < testFloatResults.Length; i++ )
			{
				source = testFloatResults[ i ].testString;
				Console.WriteLine( "     Test string {0}", source );
				IsFloatValue( out val, out charSize );
				Console.WriteLine( "     Value is: {0}, should be {1}: {2}", val, testFloatResults[ i ].val, ( val == testFloatResults[ i ].val ) ? "Passed" : "Failed" );
				Console.WriteLine( "     Char size is: {0}, should be {1}: {2}", charSize, testFloatResults[ i ].charSize, ( charSize == testFloatResults[ i ].charSize ) ? "Passed" : "Failed" );
			}

			Console.WriteLine( "**Finished testing: IsFloatValue\n" );

			// ***TEST 5***
			// Simple compile test for ps.1.4
			string CompileTest1src = "ps.1.4\n";
			Symbol[] CompileTest1result = { Symbol.PS_1_4 };
			TestCompile( "Basic PS_1_4", CompileTest1src, CompileTest1result );

			// ***TEST 6***
			// Simple compile test for ps1.1
			string CompileTest2src = "ps.1.1\n";
			Symbol[] CompileTest2result = { Symbol.PS_1_1 };
			TestCompile( "Basic PS_1_1", CompileTest2src, CompileTest2result );

			// ***TEST 7***
			// Simple compile test, ps.1.4 with defines
			string CompileTest3src = "ps.1.4\ndef c0, 1.0, 2.0, 3.0, 4.0\n";
			Symbol[] CompileTest3result = {Symbol.PS_1_4, Symbol.DEF, Symbol.C0, Symbol.COMMA, Symbol.VALUE, Symbol.COMMA,
				Symbol.VALUE, Symbol.COMMA, Symbol.VALUE, Symbol.COMMA, Symbol.VALUE};

			TestCompile( "PS_1_4 with defines", CompileTest3src, CompileTest3result );

			// ***TEST 8***
			// Simple compile test, ps.1.4 with 2 defines
			string CompileTest4src = "ps.1.4\n//test kkl \ndef c0, 1.0, 2.0, 3.0, 4.0\ndef c3, 1.0, 2.0, 3.0, 4.0\n";
			Symbol[] CompileTest4result = {Symbol.PS_1_4, Symbol.DEF, Symbol.C0, Symbol.COMMA, Symbol.VALUE, Symbol.COMMA,
				Symbol.VALUE, Symbol.COMMA, Symbol.VALUE, Symbol.COMMA, Symbol.VALUE,Symbol.DEF, Symbol.C3, Symbol.COMMA, Symbol.VALUE, Symbol.COMMA,
				Symbol.VALUE, Symbol.COMMA, Symbol.VALUE, Symbol.COMMA, Symbol.VALUE};

			TestCompile( "PS_1_4 with 2 defines", CompileTest4src, CompileTest4result );

			// ***TEST 9***
			// Simple compile test, checking machine instructions
			int[] CompileTest5MachinInstResults = { (int)MachineInstruction.SetConstants, Gl.GL_CON_0_ATI, 0 };

			TestCompile( "PS_1_4 with defines", CompileTest3src, CompileTest3result, CompileTest5MachinInstResults );

			// ***TEST 10***
			// Simple compile test, checking ALU instructions
			string CompileTest6Src = "ps.1.4\nmov r0.xzw, c1 \nmul r3, r2, c3";
			Symbol[] CompileTest6result = {Symbol.PS_1_4, Symbol.MOV, Symbol.R0, Symbol.RBA, Symbol.COMMA, Symbol.C1,
				Symbol.MUL, Symbol.R3, Symbol.COMMA, Symbol.R2, Symbol.COMMA, Symbol.C3};

			TestCompile( "PS_1_4 ALU simple", CompileTest6Src, CompileTest6result );


			// test to see if PS_1_4 compile pass 2 generates the proper machine instructions
			string CompileTest7Src = "ps.1.4\ndef c0,1.0,2.0,3.0,4.0\nmov_x8 r1,v0\nmov r0,r1.g";

			Symbol[] CompileTest7result = {
				Symbol.PS_1_4, Symbol.DEF, Symbol.C0, Symbol.COMMA, Symbol.VALUE, Symbol.COMMA,
				Symbol.VALUE, Symbol.COMMA, Symbol.VALUE, Symbol.COMMA, Symbol.VALUE, Symbol.MOV, Symbol.X8, Symbol.R1, Symbol.COMMA,
				Symbol.V0, Symbol.MOV, Symbol.R0, Symbol.COMMA, Symbol.R1, Symbol.GGGG
			};

			int[] CompileTest7MachinInstResults = {
				(int)MachineInstruction.SetConstants, Gl.GL_CON_0_ATI, 0,
				(int)MachineInstruction.ColorOp1, Gl.GL_MOV_ATI, Gl.GL_REG_1_ATI, RGB_BITS, Gl.GL_8X_BIT_ATI,	Gl.GL_PRIMARY_COLOR_ARB, Gl.GL_NONE, Gl.GL_NONE,
				(int)MachineInstruction.AlphaOp1, Gl.GL_MOV_ATI, Gl.GL_REG_1_ATI, Gl.GL_8X_BIT_ATI, Gl.GL_PRIMARY_COLOR_ARB, Gl.GL_NONE, Gl.GL_NONE,
				(int)MachineInstruction.ColorOp1, Gl.GL_MOV_ATI, Gl.GL_REG_0_ATI, RGB_BITS, Gl.GL_NONE,Gl.GL_REG_1_ATI, Gl.GL_GREEN, Gl.GL_NONE,
				(int)MachineInstruction.AlphaOp1, Gl.GL_MOV_ATI, Gl.GL_REG_0_ATI, Gl.GL_NONE, Gl.GL_REG_1_ATI, Gl.GL_GREEN, Gl.GL_NONE,
			};

			TestCompile( "PS_1_4 ALU simple modifier", CompileTest7Src, CompileTest7result, CompileTest7MachinInstResults );

			return true;
		}