using System;
using System.IO;
using NUnit.Framework;
using ICSharpCode.NRefactory.Parser;
using ICSharpCode.NRefactory.Parser.CSharp;
using ICSharpCode.NRefactory.PrettyPrinter;

namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
{
	[TestFixture]
	public sealed class LexerTests
	{
		ILexer GenerateLexer(StringReader sr)
		{
			return ParserFactory.CreateLexer(SupportedLanguages.CSharp, sr);
		}

		[Test]
		public void TestAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("="));
			Assert.AreEqual(Tokens.Assign, lexer.NextToken().kind);
		}

		[Test]
		public void TestPlus()
		{
			ILexer lexer = GenerateLexer(new StringReader("+"));
			Assert.AreEqual(Tokens.Plus, lexer.NextToken().kind);
		}

		[Test]
		public void TestMinus()
		{
			ILexer lexer = GenerateLexer(new StringReader("-"));
			Assert.AreEqual(Tokens.Minus, lexer.NextToken().kind);
		}

		[Test]
		public void TestTimes()
		{
			ILexer lexer = GenerateLexer(new StringReader("*"));
			Assert.AreEqual(Tokens.Times, lexer.NextToken().kind);
		}

		[Test]
		public void TestDiv()
		{
			ILexer lexer = GenerateLexer(new StringReader("/"));
			Assert.AreEqual(Tokens.Div, lexer.NextToken().kind);
		}

		[Test]
		public void TestMod()
		{
			ILexer lexer = GenerateLexer(new StringReader("%"));
			Assert.AreEqual(Tokens.Mod, lexer.NextToken().kind);
		}

		[Test]
		public void TestColon()
		{
			ILexer lexer = GenerateLexer(new StringReader(":"));
			Assert.AreEqual(Tokens.Colon, lexer.NextToken().kind);
		}

		[Test]
		public void TestDoubleColon()
		{
			ILexer lexer = GenerateLexer(new StringReader("::"));
			Assert.AreEqual(Tokens.DoubleColon, lexer.NextToken().kind);
		}

		[Test]
		public void TestSemicolon()
		{
			ILexer lexer = GenerateLexer(new StringReader(";"));
			Assert.AreEqual(Tokens.Semicolon, lexer.NextToken().kind);
		}

		[Test]
		public void TestQuestion()
		{
			ILexer lexer = GenerateLexer(new StringReader("?"));
			Assert.AreEqual(Tokens.Question, lexer.NextToken().kind);
		}

		[Test]
		public void TestComma()
		{
			ILexer lexer = GenerateLexer(new StringReader(","));
			Assert.AreEqual(Tokens.Comma, lexer.NextToken().kind);
		}

		[Test]
		public void TestDot()
		{
			ILexer lexer = GenerateLexer(new StringReader("."));
			Assert.AreEqual(Tokens.Dot, lexer.NextToken().kind);
		}

		[Test]
		public void TestOpenCurlyBrace()
		{
			ILexer lexer = GenerateLexer(new StringReader("{"));
			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().kind);
		}

		[Test]
		public void TestCloseCurlyBrace()
		{
			ILexer lexer = GenerateLexer(new StringReader("}"));
			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.NextToken().kind);
		}
		
		[Test]
		public void TestEmptyBlock()
		{
			ILexer lexer = GenerateLexer(new StringReader("{}"));
			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().kind);
			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.NextToken().kind);
		}
		
		[Test]
		public void TestSkippedEmptyBlock()
		{
			ILexer lexer = GenerateLexer(new StringReader("{}"));
			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().kind);
			lexer.SkipCurrentBlock();
			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.NextToken().kind);
		}
		
		[Test]
		public void TestSkippedNonEmptyBlock()
		{
			ILexer lexer = GenerateLexer(new StringReader("{ TestMethod('}'); /* }}} */ break; }"));
			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().kind);
			lexer.SkipCurrentBlock();
			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.NextToken().kind);
		}

		[Test]
		public void TestOpenSquareBracket()
		{
			ILexer lexer = GenerateLexer(new StringReader("["));
			Assert.AreEqual(Tokens.OpenSquareBracket, lexer.NextToken().kind);
		}

		[Test]
		public void TestCloseSquareBracket()
		{
			ILexer lexer = GenerateLexer(new StringReader("]"));
			Assert.AreEqual(Tokens.CloseSquareBracket, lexer.NextToken().kind);
		}

		[Test]
		public void TestOpenParenthesis()
		{
			ILexer lexer = GenerateLexer(new StringReader("("));
			Assert.AreEqual(Tokens.OpenParenthesis, lexer.NextToken().kind);
		}

		[Test]
		public void TestCloseParenthesis()
		{
			ILexer lexer = GenerateLexer(new StringReader(")"));
			Assert.AreEqual(Tokens.CloseParenthesis, lexer.NextToken().kind);
		}

		[Test]
		public void TestGreaterThan()
		{
			ILexer lexer = GenerateLexer(new StringReader(">"));
			Assert.AreEqual(Tokens.GreaterThan, lexer.NextToken().kind);
		}

		[Test]
		public void TestLessThan()
		{
			ILexer lexer = GenerateLexer(new StringReader("<"));
			Assert.AreEqual(Tokens.LessThan, lexer.NextToken().kind);
		}

		[Test]
		public void TestNot()
		{
			ILexer lexer = GenerateLexer(new StringReader("!"));
			Assert.AreEqual(Tokens.Not, lexer.NextToken().kind);
		}

		[Test]
		public void TestLogicalAnd()
		{
			ILexer lexer = GenerateLexer(new StringReader("&&"));
			Assert.AreEqual(Tokens.LogicalAnd, lexer.NextToken().kind);
		}

		[Test]
		public void TestLogicalOr()
		{
			ILexer lexer = GenerateLexer(new StringReader("||"));
			Assert.AreEqual(Tokens.LogicalOr, lexer.NextToken().kind);
		}

		[Test]
		public void TestBitwiseComplement()
		{
			ILexer lexer = GenerateLexer(new StringReader("~"));
			Assert.AreEqual(Tokens.BitwiseComplement, lexer.NextToken().kind);
		}

		[Test]
		public void TestBitwiseAnd()
		{
			ILexer lexer = GenerateLexer(new StringReader("&"));
			Assert.AreEqual(Tokens.BitwiseAnd, lexer.NextToken().kind);
		}

		[Test]
		public void TestBitwiseOr()
		{
			ILexer lexer = GenerateLexer(new StringReader("|"));
			Assert.AreEqual(Tokens.BitwiseOr, lexer.NextToken().kind);
		}

		[Test]
		public void TestXor()
		{
			ILexer lexer = GenerateLexer(new StringReader("^"));
			Assert.AreEqual(Tokens.Xor, lexer.NextToken().kind);
		}

		[Test]
		public void TestIncrement()
		{
			ILexer lexer = GenerateLexer(new StringReader("++"));
			Assert.AreEqual(Tokens.Increment, lexer.NextToken().kind);
		}

		[Test]
		public void TestDecrement()
		{
			ILexer lexer = GenerateLexer(new StringReader("--"));
			Assert.AreEqual(Tokens.Decrement, lexer.NextToken().kind);
		}

		[Test]
		public void TestEqual()
		{
			ILexer lexer = GenerateLexer(new StringReader("=="));
			Assert.AreEqual(Tokens.Equal, lexer.NextToken().kind);
		}

		[Test]
		public void TestNotEqual()
		{
			ILexer lexer = GenerateLexer(new StringReader("!="));
			Assert.AreEqual(Tokens.NotEqual, lexer.NextToken().kind);
		}

		[Test]
		public void TestGreaterEqual()
		{
			ILexer lexer = GenerateLexer(new StringReader(">="));
			Assert.AreEqual(Tokens.GreaterEqual, lexer.NextToken().kind);
		}

		[Test]
		public void TestLessEqual()
		{
			ILexer lexer = GenerateLexer(new StringReader("<="));
			Assert.AreEqual(Tokens.LessEqual, lexer.NextToken().kind);
		}

		[Test]
		public void TestShiftLeft()
		{
			ILexer lexer = GenerateLexer(new StringReader("<<"));
			Assert.AreEqual(Tokens.ShiftLeft, lexer.NextToken().kind);
		}

//		[Test]
//		public void TestShiftRight()
//		{
//			ILexer lexer = GenerateLexer(new StringReader(">>"));
//			Assert.AreEqual(Tokens.ShiftRight, lexer.NextToken().kind);
//		}

		[Test]
		public void TestPlusAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("+="));
			Assert.AreEqual(Tokens.PlusAssign, lexer.NextToken().kind);
		}

		[Test]
		public void TestMinusAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("-="));
			Assert.AreEqual(Tokens.MinusAssign, lexer.NextToken().kind);
		}

		[Test]
		public void TestTimesAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("*="));
			Assert.AreEqual(Tokens.TimesAssign, lexer.NextToken().kind);
		}

		[Test]
		public void TestDivAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("/="));
			Assert.AreEqual(Tokens.DivAssign, lexer.NextToken().kind);
		}

		[Test]
		public void TestModAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("%="));
			Assert.AreEqual(Tokens.ModAssign, lexer.NextToken().kind);
		}

		[Test]
		public void TestBitwiseAndAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("&="));
			Assert.AreEqual(Tokens.BitwiseAndAssign, lexer.NextToken().kind);
		}

		[Test]
		public void TestBitwiseOrAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("|="));
			Assert.AreEqual(Tokens.BitwiseOrAssign, lexer.NextToken().kind);
		}

		[Test]
		public void TestXorAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("^="));
			Assert.AreEqual(Tokens.XorAssign, lexer.NextToken().kind);
		}

		[Test]
		public void TestShiftLeftAssign()
		{
			ILexer lexer = GenerateLexer(new StringReader("<<="));
			Assert.AreEqual(Tokens.ShiftLeftAssign, lexer.NextToken().kind);
		}

//		[Test]
//		public void TestShiftRightAssign()
//		{
//			ILexer lexer = GenerateLexer(new StringReader(">>="));
//			Assert.AreEqual(Tokens.ShiftRightAssign, lexer.NextToken().kind);
//		}

		[Test()]
		public void TestAbstract()
		{
			ILexer lexer = GenerateLexer(new StringReader("abstract"));
			Assert.AreEqual(Tokens.Abstract, lexer.NextToken().kind);
		}
		[Test()]
		public void TestAs()
		{
			ILexer lexer = GenerateLexer(new StringReader("as"));
			Assert.AreEqual(Tokens.As, lexer.NextToken().kind);
		}
		[Test()]
		public void TestBase()
		{
			ILexer lexer = GenerateLexer(new StringReader("base"));
			Assert.AreEqual(Tokens.Base, lexer.NextToken().kind);
		}
		[Test()]
		public void TestBool()
		{
			ILexer lexer = GenerateLexer(new StringReader("bool"));
			Assert.AreEqual(Tokens.Bool, lexer.NextToken().kind);
		}
		[Test()]
		public void TestBreak()
		{
			ILexer lexer = GenerateLexer(new StringReader("break"));
			Assert.AreEqual(Tokens.Break, lexer.NextToken().kind);
		}
		[Test()]
		public void TestByte()
		{
			ILexer lexer = GenerateLexer(new StringReader("byte"));
			Assert.AreEqual(Tokens.Byte, lexer.NextToken().kind);
		}
		[Test()]
		public void TestCase()
		{
			ILexer lexer = GenerateLexer(new StringReader("case"));
			Assert.AreEqual(Tokens.Case, lexer.NextToken().kind);
		}
		[Test()]
		public void TestCatch()
		{
			ILexer lexer = GenerateLexer(new StringReader("catch"));
			Assert.AreEqual(Tokens.Catch, lexer.NextToken().kind);
		}
		[Test()]
		public void TestChar()
		{
			ILexer lexer = GenerateLexer(new StringReader("char"));
			Assert.AreEqual(Tokens.Char, lexer.NextToken().kind);
		}
		[Test()]
		public void TestChecked()
		{
			ILexer lexer = GenerateLexer(new StringReader("checked"));
			Assert.AreEqual(Tokens.Checked, lexer.NextToken().kind);
		}
		[Test()]
		public void TestClass()
		{
			ILexer lexer = GenerateLexer(new StringReader("class"));
			Assert.AreEqual(Tokens.Class, lexer.NextToken().kind);
		}
		[Test()]
		public void TestConst()
		{
			ILexer lexer = GenerateLexer(new StringReader("const"));
			Assert.AreEqual(Tokens.Const, lexer.NextToken().kind);
		}
		[Test()]
		public void TestContinue()
		{
			ILexer lexer = GenerateLexer(new StringReader("continue"));
			Assert.AreEqual(Tokens.Continue, lexer.NextToken().kind);
		}
		[Test()]
		public void TestDecimal()
		{
			ILexer lexer = GenerateLexer(new StringReader("decimal"));
			Assert.AreEqual(Tokens.Decimal, lexer.NextToken().kind);
		}
		[Test()]
		public void TestDefault()
		{
			ILexer lexer = GenerateLexer(new StringReader("default"));
			Assert.AreEqual(Tokens.Default, lexer.NextToken().kind);
		}
		[Test()]
		public void TestDelegate()
		{
			ILexer lexer = GenerateLexer(new StringReader("delegate"));
			Assert.AreEqual(Tokens.Delegate, lexer.NextToken().kind);
		}
		[Test()]
		public void TestDo()
		{
			ILexer lexer = GenerateLexer(new StringReader("do"));
			Assert.AreEqual(Tokens.Do, lexer.NextToken().kind);
		}
		[Test()]
		public void TestDouble()
		{
			ILexer lexer = GenerateLexer(new StringReader("double"));
			Assert.AreEqual(Tokens.Double, lexer.NextToken().kind);
		}
		[Test()]
		public void TestElse()
		{
			ILexer lexer = GenerateLexer(new StringReader("else"));
			Assert.AreEqual(Tokens.Else, lexer.NextToken().kind);
		}
		[Test()]
		public void TestEnum()
		{
			ILexer lexer = GenerateLexer(new StringReader("enum"));
			Assert.AreEqual(Tokens.Enum, lexer.NextToken().kind);
		}
		[Test()]
		public void TestEvent()
		{
			ILexer lexer = GenerateLexer(new StringReader("event"));
			Assert.AreEqual(Tokens.Event, lexer.NextToken().kind);
		}
		[Test()]
		public void TestExplicit()
		{
			ILexer lexer = GenerateLexer(new StringReader("explicit"));
			Assert.AreEqual(Tokens.Explicit, lexer.NextToken().kind);
		}
		[Test()]
		public void TestExtern()
		{
			ILexer lexer = GenerateLexer(new StringReader("extern"));
			Assert.AreEqual(Tokens.Extern, lexer.NextToken().kind);
		}
		[Test()]
		public void TestFalse()
		{
			ILexer lexer = GenerateLexer(new StringReader("false"));
			Assert.AreEqual(Tokens.False, lexer.NextToken().kind);
		}
		[Test()]
		public void TestFinally()
		{
			ILexer lexer = GenerateLexer(new StringReader("finally"));
			Assert.AreEqual(Tokens.Finally, lexer.NextToken().kind);
		}
		[Test()]
		public void TestFixed()
		{
			ILexer lexer = GenerateLexer(new StringReader("fixed"));
			Assert.AreEqual(Tokens.Fixed, lexer.NextToken().kind);
		}
		[Test()]
		public void TestFloat()
		{
			ILexer lexer = GenerateLexer(new StringReader("float"));
			Assert.AreEqual(Tokens.Float, lexer.NextToken().kind);
		}
		[Test()]
		public void TestFor()
		{
			ILexer lexer = GenerateLexer(new StringReader("for"));
			Assert.AreEqual(Tokens.For, lexer.NextToken().kind);
		}
		[Test()]
		public void TestForeach()
		{
			ILexer lexer = GenerateLexer(new StringReader("foreach"));
			Assert.AreEqual(Tokens.Foreach, lexer.NextToken().kind);
		}
		[Test()]
		public void TestGoto()
		{
			ILexer lexer = GenerateLexer(new StringReader("goto"));
			Assert.AreEqual(Tokens.Goto, lexer.NextToken().kind);
		}
		[Test()]
		public void TestIf()
		{
			ILexer lexer = GenerateLexer(new StringReader("if"));
			Assert.AreEqual(Tokens.If, lexer.NextToken().kind);
		}
		[Test()]
		public void TestImplicit()
		{
			ILexer lexer = GenerateLexer(new StringReader("implicit"));
			Assert.AreEqual(Tokens.Implicit, lexer.NextToken().kind);
		}
		[Test()]
		public void TestIn()
		{
			ILexer lexer = GenerateLexer(new StringReader("in"));
			Assert.AreEqual(Tokens.In, lexer.NextToken().kind);
		}
		[Test()]
		public void TestInt()
		{
			ILexer lexer = GenerateLexer(new StringReader("int"));
			Assert.AreEqual(Tokens.Int, lexer.NextToken().kind);
		}
		[Test()]
		public void TestInterface()
		{
			ILexer lexer = GenerateLexer(new StringReader("interface"));
			Assert.AreEqual(Tokens.Interface, lexer.NextToken().kind);
		}
		[Test()]
		public void TestInternal()
		{
			ILexer lexer = GenerateLexer(new StringReader("internal"));
			Assert.AreEqual(Tokens.Internal, lexer.NextToken().kind);
		}
		[Test()]
		public void TestIs()
		{
			ILexer lexer = GenerateLexer(new StringReader("is"));
			Assert.AreEqual(Tokens.Is, lexer.NextToken().kind);
		}
		[Test()]
		public void TestLock()
		{
			ILexer lexer = GenerateLexer(new StringReader("lock"));
			Assert.AreEqual(Tokens.Lock, lexer.NextToken().kind);
		}
		[Test()]
		public void TestLong()
		{
			ILexer lexer = GenerateLexer(new StringReader("long"));
			Assert.AreEqual(Tokens.Long, lexer.NextToken().kind);
		}
		[Test()]
		public void TestNamespace()
		{
			ILexer lexer = GenerateLexer(new StringReader("namespace"));
			Assert.AreEqual(Tokens.Namespace, lexer.NextToken().kind);
		}
		[Test()]
		public void TestNew()
		{
			ILexer lexer = GenerateLexer(new StringReader("new"));
			Assert.AreEqual(Tokens.New, lexer.NextToken().kind);
		}
		[Test()]
		public void TestNull()
		{
			ILexer lexer = GenerateLexer(new StringReader("null"));
			Assert.AreEqual(Tokens.Null, lexer.NextToken().kind);
		}
		[Test()]
		public void TestObject()
		{
			ILexer lexer = GenerateLexer(new StringReader("object"));
			Assert.AreEqual(Tokens.Object, lexer.NextToken().kind);
		}
		[Test()]
		public void TestOperator()
		{
			ILexer lexer = GenerateLexer(new StringReader("operator"));
			Assert.AreEqual(Tokens.Operator, lexer.NextToken().kind);
		}
		[Test()]
		public void TestOut()
		{
			ILexer lexer = GenerateLexer(new StringReader("out"));
			Assert.AreEqual(Tokens.Out, lexer.NextToken().kind);
		}
		[Test()]
		public void TestOverride()
		{
			ILexer lexer = GenerateLexer(new StringReader("override"));
			Assert.AreEqual(Tokens.Override, lexer.NextToken().kind);
		}
		[Test()]
		public void TestParams()
		{
			ILexer lexer = GenerateLexer(new StringReader("params"));
			Assert.AreEqual(Tokens.Params, lexer.NextToken().kind);
		}
		[Test()]
		public void TestPrivate()
		{
			ILexer lexer = GenerateLexer(new StringReader("private"));
			Assert.AreEqual(Tokens.Private, lexer.NextToken().kind);
		}
		[Test()]
		public void TestProtected()
		{
			ILexer lexer = GenerateLexer(new StringReader("protected"));
			Assert.AreEqual(Tokens.Protected, lexer.NextToken().kind);
		}
		[Test()]
		public void TestPublic()
		{
			ILexer lexer = GenerateLexer(new StringReader("public"));
			Assert.AreEqual(Tokens.Public, lexer.NextToken().kind);
		}
		[Test()]
		public void TestReadonly()
		{
			ILexer lexer = GenerateLexer(new StringReader("readonly"));
			Assert.AreEqual(Tokens.Readonly, lexer.NextToken().kind);
		}
		[Test()]
		public void TestRef()
		{
			ILexer lexer = GenerateLexer(new StringReader("ref"));
			Assert.AreEqual(Tokens.Ref, lexer.NextToken().kind);
		}
		[Test()]
		public void TestReturn()
		{
			ILexer lexer = GenerateLexer(new StringReader("return"));
			Assert.AreEqual(Tokens.Return, lexer.NextToken().kind);
		}
		[Test()]
		public void TestSbyte()
		{
			ILexer lexer = GenerateLexer(new StringReader("sbyte"));
			Assert.AreEqual(Tokens.Sbyte, lexer.NextToken().kind);
		}
		[Test()]
		public void TestSealed()
		{
			ILexer lexer = GenerateLexer(new StringReader("sealed"));
			Assert.AreEqual(Tokens.Sealed, lexer.NextToken().kind);
		}
		[Test()]
		public void TestShort()
		{
			ILexer lexer = GenerateLexer(new StringReader("short"));
			Assert.AreEqual(Tokens.Short, lexer.NextToken().kind);
		}
		[Test()]
		public void TestSizeof()
		{
			ILexer lexer = GenerateLexer(new StringReader("sizeof"));
			Assert.AreEqual(Tokens.Sizeof, lexer.NextToken().kind);
		}
		[Test()]
		public void TestStackalloc()
		{
			ILexer lexer = GenerateLexer(new StringReader("stackalloc"));
			Assert.AreEqual(Tokens.Stackalloc, lexer.NextToken().kind);
		}
		[Test()]
		public void TestStatic()
		{
			ILexer lexer = GenerateLexer(new StringReader("static"));
			Assert.AreEqual(Tokens.Static, lexer.NextToken().kind);
		}
		[Test()]
		public void TestString()
		{
			ILexer lexer = GenerateLexer(new StringReader("string"));
			Assert.AreEqual(Tokens.String, lexer.NextToken().kind);
		}
		[Test()]
		public void TestStruct()
		{
			ILexer lexer = GenerateLexer(new StringReader("struct"));
			Assert.AreEqual(Tokens.Struct, lexer.NextToken().kind);
		}
		[Test()]
		public void TestSwitch()
		{
			ILexer lexer = GenerateLexer(new StringReader("switch"));
			Assert.AreEqual(Tokens.Switch, lexer.NextToken().kind);
		}
		[Test()]
		public void TestThis()
		{
			ILexer lexer = GenerateLexer(new StringReader("this"));
			Assert.AreEqual(Tokens.This, lexer.NextToken().kind);
		}
		[Test()]
		public void TestThrow()
		{
			ILexer lexer = GenerateLexer(new StringReader("throw"));
			Assert.AreEqual(Tokens.Throw, lexer.NextToken().kind);
		}
		[Test()]
		public void TestTrue()
		{
			ILexer lexer = GenerateLexer(new StringReader("true"));
			Assert.AreEqual(Tokens.True, lexer.NextToken().kind);
		}
		[Test()]
		public void TestTry()
		{
			ILexer lexer = GenerateLexer(new StringReader("try"));
			Assert.AreEqual(Tokens.Try, lexer.NextToken().kind);
		}
		[Test()]
		public void TestTypeof()
		{
			ILexer lexer = GenerateLexer(new StringReader("typeof"));
			Assert.AreEqual(Tokens.Typeof, lexer.NextToken().kind);
		}
		[Test()]
		public void TestUint()
		{
			ILexer lexer = GenerateLexer(new StringReader("uint"));
			Assert.AreEqual(Tokens.Uint, lexer.NextToken().kind);
		}
		[Test()]
		public void TestUlong()
		{
			ILexer lexer = GenerateLexer(new StringReader("ulong"));
			Assert.AreEqual(Tokens.Ulong, lexer.NextToken().kind);
		}
		[Test()]
		public void TestUnchecked()
		{
			ILexer lexer = GenerateLexer(new StringReader("unchecked"));
			Assert.AreEqual(Tokens.Unchecked, lexer.NextToken().kind);
		}
		[Test()]
		public void TestUnsafe()
		{
			ILexer lexer = GenerateLexer(new StringReader("unsafe"));
			Assert.AreEqual(Tokens.Unsafe, lexer.NextToken().kind);
		}
		[Test()]
		public void TestUshort()
		{
			ILexer lexer = GenerateLexer(new StringReader("ushort"));
			Assert.AreEqual(Tokens.Ushort, lexer.NextToken().kind);
		}
		[Test()]
		public void TestUsing()
		{
			ILexer lexer = GenerateLexer(new StringReader("using"));
			Assert.AreEqual(Tokens.Using, lexer.NextToken().kind);
		}
		[Test()]
		public void TestVirtual()
		{
			ILexer lexer = GenerateLexer(new StringReader("virtual"));
			Assert.AreEqual(Tokens.Virtual, lexer.NextToken().kind);
		}
		[Test()]
		public void TestVoid()
		{
			ILexer lexer = GenerateLexer(new StringReader("void"));
			Assert.AreEqual(Tokens.Void, lexer.NextToken().kind);
		}
		[Test()]
		public void TestVolatile()
		{
			ILexer lexer = GenerateLexer(new StringReader("volatile"));
			Assert.AreEqual(Tokens.Volatile, lexer.NextToken().kind);
		}
		[Test()]
		public void TestWhile()
		{
			ILexer lexer = GenerateLexer(new StringReader("while"));
			Assert.AreEqual(Tokens.While, lexer.NextToken().kind);
		}
	}
}