debuggertests.cs

SharpDevelop2.0.0 c#开发免费工具

			List<Variable> args;
			
			StartProgram("FunctionLocalVariables");
			WaitForPause(PausedReason.Break, null);
			args = new List<Variable>(debugger.SelectedFunction.LocalVariables);
			// names
			Assert.AreEqual("i", args[0].Name);
			Assert.AreEqual("s", args[1].Name);
			Assert.AreEqual("args", args[2].Name);
			Assert.AreEqual("n", args[3].Name);
			Assert.AreEqual("o", args[4].Name);
			// types
			Assert.AreEqual(typeof(PrimitiveValue), args[0].Value.GetType());
			Assert.AreEqual(typeof(PrimitiveValue), args[1].Value.GetType());
			Assert.AreEqual(typeof(ArrayValue),     args[2].Value.GetType());
			Assert.AreEqual(typeof(NullValue),     args[3].Value.GetType());
			Assert.AreEqual(typeof(ObjectValue),     args[4].Value.GetType());
			// values
			Assert.AreEqual("0", args[0].Value.AsString);
			Assert.AreEqual("S", args[1].Value.AsString);
			Assert.AreEqual(1 ,((ArrayValue)args[2].Value).Lenght);
			Assert.IsNotNull(args[3].Value.AsString);
			Assert.AreEqual("{System.Object}", args[4].Value.AsString);
			
			debugger.Continue();
			debugger.WaitForPrecessExit();
		}
		
		[Test]
		public void FunctionLifetime()
		{
			Function function;
			
			StartProgram("FunctionLifetime");
			WaitForPause(PausedReason.Break, null);
			function = debugger.SelectedFunction;
			Assert.IsNotNull(function);
			Assert.AreEqual("Function", function.Name);
			Assert.AreEqual(false, function.HasExpired);
			Assert.AreEqual("1", function.GetArgumentVariable(0).Value.AsString);
			
			debugger.Continue(); // Go to the SubFunction
			WaitForPause(PausedReason.Break, null);
			Assert.AreEqual("SubFunction", debugger.SelectedFunction.Name);
			Assert.AreEqual(false, function.HasExpired);
			Assert.AreEqual("1", function.GetArgumentVariable(0).Value.AsString);
			
			debugger.Continue(); // Go back to Function
			WaitForPause(PausedReason.Break, null);
			Assert.AreEqual("Function", debugger.SelectedFunction.Name);
			Assert.AreEqual(false, function.HasExpired);
			Assert.AreEqual("1", function.GetArgumentVariable(0).Value.AsString);
			
			debugger.Continue(); // Setp out of function
			WaitForPause(PausedReason.Break, null);
			Assert.AreEqual("Main", debugger.SelectedFunction.Name);
			Assert.AreEqual(true, function.HasExpired);
			
			debugger.Continue();
			debugger.WaitForPrecessExit();
		}
		
		[Test]
		public void FunctionVariablesLifetime()
		{
			Function function = null;
			Variable argument = null;
			Variable local    = null;
			Variable localInSubFunction = null;
			Variable @class   = null;
			
			StartProgram("FunctionVariablesLifetime"); // 1 - Enter program
			WaitForPause(PausedReason.Break, null);
			function = debugger.SelectedFunction;
			Assert.IsNotNull(function);
			Assert.AreEqual("Function", function.Name);
			argument = function.GetArgumentVariable(0);
			foreach(Variable var in function.LocalVariables) {
				local = var;
			}
			foreach(Variable var in function.ContaingClassVariables) {
				@class = var;
			}
			Assert.IsNotNull(argument);
			Assert.IsNotNull(local);
			Assert.IsNotNull(@class);
			Assert.AreEqual("argument", argument.Name);
			Assert.AreEqual("local", local.Name);
			Assert.AreEqual("class", @class.Name);
			Assert.AreEqual("1", argument.Value.AsString);
			Assert.AreEqual("2", local.Value.AsString);
			Assert.AreEqual("3", @class.Value.AsString);
			
			debugger.Continue(); // 2 - Go to the SubFunction
			WaitForPause(PausedReason.Break, null);
			Assert.AreEqual("1", argument.Value.AsString);
			Assert.AreEqual("2", local.Value.AsString);
			Assert.AreEqual("3", @class.Value.AsString);
			// Check localInSubFunction variable
			localInSubFunction = debugger.LocalVariables["localInSubFunction"];
			Assert.AreEqual("4", localInSubFunction.Value.AsString);
			
			debugger.Continue(); // 3 - Go back to Function
			WaitForPause(PausedReason.Break, null);
			Assert.AreEqual("1", argument.Value.AsString);
			Assert.AreEqual("2", local.Value.AsString);
			Assert.AreEqual("3", @class.Value.AsString);
			// localInSubFunction should be dead now
			Assert.AreEqual(typeof(UnavailableValue), localInSubFunction.Value.GetType());
			
			debugger.Continue(); // 4 - Go to the SubFunction
			WaitForPause(PausedReason.Break, null);
			Assert.AreEqual("1", argument.Value.AsString);
			Assert.AreEqual("2", local.Value.AsString);
			Assert.AreEqual("3", @class.Value.AsString);
			// localInSubFunction should be still dead...
			Assert.AreEqual(typeof(UnavailableValue), localInSubFunction.Value.GetType());
			// ... , but we should able to get new one
			localInSubFunction = debugger.LocalVariables["localInSubFunction"];
			Assert.AreEqual("4", localInSubFunction.Value.AsString);
			
			debugger.Continue(); // 5 - Setp out of both functions
			WaitForPause(PausedReason.Break, null);
			Assert.AreEqual(typeof(UnavailableValue), argument.Value.GetType());
			Assert.AreEqual(typeof(UnavailableValue), local.Value.GetType());
			Assert.AreEqual(typeof(UnavailableValue), @class.Value.GetType());
			
			debugger.Continue();
			debugger.WaitForPrecessExit();
		}
		
		[Test]
		public void ArrayValue()
		{
			Variable local = null;
			List<Variable> subVars = new List<Variable>();
			
			StartProgram("ArrayValue");
			WaitForPause(PausedReason.Break, null);
			foreach(Variable var in debugger.SelectedFunction.LocalVariables) {
				local = var; break;
			}
			Assert.AreEqual("array", local.Name);
			Assert.AreEqual(true, local.MayHaveSubVariables);
			Assert.AreEqual(typeof(ArrayValue), local.Value.GetType());
			Assert.AreEqual("{System.Int32[5]}", local.Value.AsString);
			foreach(Variable var in local.SubVariables) {
				subVars.Add(var);
			}
			for(int i = 0; i < 5; i++) {
				Assert.AreEqual("[" + i.ToString() + "]", subVars[i].Name);
				Assert.AreEqual(i.ToString(), subVars[i].Value.AsString);
			}
			
			debugger.Continue();
			debugger.WaitForPrecessExit();
		}
		
		[Test]
		public void ObjectValue()
		{
			Variable local = null;
			Variable baseClass;
			List<Variable> subVars = new List<Variable>();
			
			StartProgram("ObjectValue");
			WaitForPause(PausedReason.Break, null);
			foreach(Variable var in debugger.SelectedFunction.LocalVariables) {
				local = var;
			}
			Assert.AreEqual("val", local.Name);
			Assert.AreEqual(true, local.MayHaveSubVariables);
			Assert.AreEqual(typeof(ObjectValue), local.Value.GetType());
			Assert.AreEqual("{Debugger.Tests.TestPrograms.ObjectValue}", local.Value.AsString);
			foreach(Variable var in local.SubVariables) {
				subVars.Add(var);
			}
			Assert.AreEqual("privateField", subVars[1].Name);
			Assert.AreEqual("publicFiled", subVars[2].Name);
			Assert.AreEqual("PublicProperty", subVars[3].Name);
			Assert.AreEqual(typeof(ClassVariable), subVars[1].GetType());
			Assert.AreEqual(typeof(ClassVariable), subVars[2].GetType());
			Assert.AreEqual(typeof(PropertyVariable), subVars[3].GetType());
			Assert.AreEqual(false, ((ClassVariable)subVars[1]).IsPublic);
			Assert.AreEqual(true, ((ClassVariable)subVars[2]).IsPublic);
			Assert.AreEqual(true, ((ClassVariable)subVars[3]).IsPublic);
			Assert.AreEqual(true, ((ObjectValue)local.Value).HasBaseClass);
			baseClass = subVars[0];
			Assert.AreEqual(typeof(ObjectValue), baseClass.Value.GetType());
			Assert.AreEqual(false, baseClass.Value.IsExpired);
			Assert.AreEqual("{Debugger.Tests.TestPrograms.BaseClass}", baseClass.Value.AsString);
			
			debugger.Continue();
			WaitForPause(PausedReason.Break, null);
			Assert.AreEqual(typeof(ObjectValue), baseClass.Value.GetType());
			Assert.AreEqual(false, baseClass.Value.IsExpired);
			Assert.AreEqual("{Debugger.Tests.TestPrograms.BaseClass}", baseClass.Value.AsString);
			
			debugger.Continue();
			debugger.WaitForPrecessExit();
		}
		
		[Test]
		public void PropertyVariable()
		{
			Variable local = null;
			List<Variable> subVars = new List<Variable>();
			
			StartProgram("PropertyVariable");
			WaitForPause(PausedReason.Break, null);
			foreach(Variable var in debugger.SelectedFunction.LocalVariables) {
				local = var;
			}
			foreach(Variable var in local.SubVariables) {
				subVars.Add(var);
			}
			Assert.AreEqual("PrivateProperty", subVars[1].Name);
			Assert.AreEqual("PublicProperty", subVars[2].Name);
			Assert.AreEqual("ExceptionProperty", subVars[3].Name);
			Assert.AreEqual("StaticProperty", subVars[4].Name);
			
			Assert.AreEqual(typeof(UnavailableValue), subVars[1].Value.GetType());
			debugger.StartEvaluation();
			WaitForPause(PausedReason.EvalComplete, null);
			Assert.AreEqual("private", subVars[1].Value.AsString);
			
			Assert.AreEqual(typeof(UnavailableValue), subVars[2].Value.GetType());
			debugger.StartEvaluation();
			WaitForPause(PausedReason.EvalComplete, null);
			Assert.AreEqual("public", subVars[2].Value.AsString);
			
			Assert.AreEqual(typeof(UnavailableValue), subVars[3].Value.GetType());
			debugger.StartEvaluation();
			WaitForPause(PausedReason.EvalComplete, null);
			Assert.AreEqual(typeof(UnavailableValue), subVars[3].Value.GetType());
			
			Assert.AreEqual(typeof(UnavailableValue), subVars[4].Value.GetType());
			debugger.StartEvaluation();
			WaitForPause(PausedReason.EvalComplete, null);
			Assert.AreEqual("static", subVars[4].Value.AsString);
			
			debugger.Continue();
			WaitForPause(PausedReason.Break, null);
			
			debugger.Continue();
			debugger.WaitForPrecessExit();
		}
		
		[Test]
		public void PropertyVariableForm()
		{
			Variable local = null;
			
			StartProgram("PropertyVariableForm");
			WaitForPause(PausedReason.Break, null);
			foreach(Variable var in debugger.SelectedFunction.LocalVariables) {
				local = var;
			}
			Assert.AreEqual("form", local.Name);
			Assert.AreEqual(typeof(Variable), local.GetType());
			
			foreach(Variable var in local.SubVariables) {
				if (var is PropertyVariable) {
					Assert.AreEqual(typeof(UnavailableValue), var.Value.GetType(), "Variable name: " + var.Name);
					debugger.StartEvaluation();
					WaitForPause(PausedReason.EvalComplete, null);
					Assert.AreEqual(false, var.Value.IsExpired, "Variable name: " + var.Name);
					Assert.AreNotEqual(null, var.Value.AsString, "Variable name: " + var.Name);
				}
			}
			
			debugger.Continue();
			WaitForPause(PausedReason.Break, null);
			
			foreach(Variable var in local.SubVariables) {
				if (var is PropertyVariable) {
					Assert.AreEqual(typeof(UnavailableValue), var.Value.GetType(), "Variable name: " + var.Name);
				}
			}
			debugger.StartEvaluation();
			WaitForPause(PausedReason.EvalComplete, null);
			
			debugger.Continue();
			debugger.WaitForPrecessExit();
		}
		
		[Test]
		public void SetIP()
		{
			StartProgram("SetIP");
			WaitForPause(PausedReason.Break, "1");
			
			Assert.IsNotNull(debugger.SelectedFunction.CanSetIP("SetIP.cs", 16, 0));
			Assert.IsNull(debugger.SelectedFunction.CanSetIP("SetIP.cs", 100, 0));
			debugger.SelectedFunction.SetIP("SetIP.cs", 16, 0);
			debugger.Continue();
			WaitForPause(PausedReason.Break, "1");
			Assert.AreEqual("1\r\n1\r\n", log);
			
			debugger.Continue();
			debugger.WaitForPrecessExit();
		}
	}
}