Category

Development Platform
Home > SourceCode/Document > Mathimatics-Numerical algorithms > matlab > View Code
DebuggerTests.cs
Package: SharpDevelop_2.2.0.2595_Source.zip　[view]
Upload User: gzlwc0706
Upload Date: 2008-08-11
Package Size: 13675k
Code Size: 21k
Category:

matlab

Development Platform:

C#

DebuggerTests.cs：Code Content
  1. // <file>
  2. //     <copyright see="prj:///doc/copyright.txt"/>
  3. //     <license see="prj:///doc/license.txt"/>
  4. //     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
  5. //     <version>$Revision: 1833 $</version>
  6. // </file>
  8. using Debugger;
  9. using Microsoft.CSharp;
  10. using NUnit.Framework;
  11. using System;
  12. using System.CodeDom.Compiler;
  13. using System.Collections;
  14. using System.Collections.Generic;
  15. using System.IO;
  16. using System.Reflection;
  17. using System.Resources;
  18. using System.Threading;
  20. namespace Debugger.Tests
  21. {
  22. /// <summary>
  23. /// This class contains methods that test the debugger
  24. /// </summary>
  25. [TestFixture]
  26. public class DebuggerTests
  27. {
  28. // NDebugger debugger;
  29. // string log;
  30. // string lastLogMessage;
  31. // string assemblyFilename;
  32. // string assemblyDir;
  33. // string symbolsFilename;
  34. //
  35. // public DebuggerTests()
  36. // {
  37. // assemblyFilename = Assembly.GetExecutingAssembly().Location;
  38. // assemblyDir = Path.GetDirectoryName(assemblyFilename);
  39. // symbolsFilename = Path.Combine(assemblyDir, Path.GetFileNameWithoutExtension(assemblyFilename) + ".pdb");
  40. //
  41. // debugger = new NDebugger();
  42. // debugger.MTA2STA.CallMethod = CallMethod.Manual;
  43. // debugger.LogMessage += delegate(object sender, MessageEventArgs e) {
  44. // log += e.Message;
  45. // lastLogMessage = e.Message;
  46. // };
  47. // }
  48. //
  49. // [TearDown]
  50. // public void TearDown()
  51. // {
  52. // debugger.Terminate();
  53. // }
  54. //
  55. // void StartProgram(string programName)
  56. // {
  57. // StartProgram(assemblyFilename, programName);
  58. // }
  59. //
  60. // void StartProgram(string exeFilename, string programName)
  61. // {
  62. // log = "";
  63. // lastLogMessage = null;
  64. // debugger.Terminate();
  65. // debugger.Start(exeFilename, Path.GetDirectoryName(exeFilename), programName);
  66. // }
  67. //
  68. // void WaitForPause(PausedReason expectedReason)
  69. // {
  70. // debugger.WaitForPause();
  71. // Assert.AreEqual(true, debugger.IsPaused);
  72. // Assert.AreEqual(expectedReason, debugger.PausedReason);
  73. // }
  74. //
  75. // void WaitForPause(PausedReason expectedReason, string expectedLastLogMessage)
  76. // {
  77. // WaitForPause(expectedReason);
  78. // if (expectedLastLogMessage != null) expectedLastLogMessage += "rn";
  79. // Assert.AreEqual(expectedLastLogMessage, lastLogMessage);
  80. // }
  81. //
  82. //
  83. // [Test]
  84. // public void SimpleProgram()
  85. // {
  86. // StartProgram("SimpleProgram");
  87. // debugger.WaitForPrecessExit();
  88. // }
  89. //
  90. // [Test]
  91. // public void HelloWorld()
  92. // {
  93. // StartProgram("HelloWorld");
  94. // debugger.WaitForPrecessExit();
  95. // Assert.AreEqual("Hello world!rn", log);
  96. // }
  97. //
  98. // [Test]
  99. // public void Break()
  100. // {
  101. // StartProgram("Break");
  102. // WaitForPause(PausedReason.Break, null);
  103. //
  104. // debugger.Continue();
  105. // debugger.WaitForPrecessExit();
  106. // }
  107. //
  108. // [Test]
  109. // public void Symbols()
  110. // {
  111. // Assert.AreEqual("debugger.tests.exe", Path.GetFileName(assemblyFilename).ToLower());
  112. // Assert.IsTrue(File.Exists(symbolsFilename), "Symbols file not found (.pdb)");
  113. //
  114. // StartProgram("Symbols");
  115. // WaitForPause(PausedReason.Break, null);
  116. // Assert.AreEqual(true, debugger.GetModule(Path.GetFileName(assemblyFilename)).SymbolsLoaded, "Module symbols not loaded");
  117. //
  118. // debugger.Continue();
  119. // debugger.WaitForPrecessExit();
  120. // }
  121. //
  122. // [Test]
  123. // public void Breakpoint()
  124. // {
  125. // Breakpoint b = debugger.AddBreakpoint(@"D:corsavySharpDevelopsrcAddInsMiscDebuggerDebugger.TestsProjectSrcTestProgramsBreakpoint.cs", 18);
  126. //
  127. // StartProgram("Breakpoint");
  128. // WaitForPause(PausedReason.Break, null);
  129. // Assert.AreEqual(true, b.Enabled);
  130. // Assert.AreEqual(true, b.HadBeenSet, "Breakpoint is not set");
  131. // Assert.AreEqual(18, b.SourcecodeSegment.StartLine);
  132. //
  133. // debugger.Continue();
  134. // WaitForPause(PausedReason.Breakpoint, "Mark 1");
  135. //
  136. // debugger.Continue();
  137. // WaitForPause(PausedReason.Break, "Mark 2");
  138. //
  139. // debugger.Continue();
  140. // debugger.WaitForPrecessExit();
  141. // Assert.AreEqual("Mark 1rnMark 2rn", log);
  142. // }
  143. //
  144. // [Test]
  145. // public void FileRelease()
  146. // {
  147. // Assert.IsTrue(File.Exists(assemblyFilename), "Assembly file not found");
  148. // Assert.IsTrue(File.Exists(symbolsFilename), "Symbols file not found (.pdb)");
  149. //
  150. // string tempPath = Path.Combine(Path.GetTempPath(), Path.Combine("DebeggerTest", new Random().Next().ToString()));
  151. // Directory.CreateDirectory(tempPath);
  152. //
  153. // string newAssemblyFilename = Path.Combine(tempPath, Path.GetFileName(assemblyFilename));
  154. // string newSymbolsFilename = Path.Combine(tempPath, Path.GetFileName(symbolsFilename));
  155. //
  156. // File.Copy(assemblyFilename, newAssemblyFilename);
  157. // File.Copy(symbolsFilename, newSymbolsFilename);
  158. //
  159. // Assert.IsTrue(File.Exists(newAssemblyFilename), "Assembly file copying failed");
  160. // Assert.IsTrue(File.Exists(newSymbolsFilename), "Symbols file copying failed");
  161. //
  162. // StartProgram(newAssemblyFilename, "FileRelease");
  163. // debugger.WaitForPrecessExit();
  164. //
  165. // try {
  166. // File.Delete(newAssemblyFilename);
  167. // } catch (System.Exception e) {
  168. // Assert.Fail("Assembly file not releasedn" + e.ToString());
  169. // }
  170. //
  171. // try {
  172. // File.Delete(newSymbolsFilename);
  173. // } catch (System.Exception e) {
  174. // Assert.Fail("Symbols file not releasedn" + e.ToString());
  175. // }
  176. // }
  177. //
  178. // [Test]
  179. // public void DebuggeeKilled()
  180. // {
  181. // StartProgram("DebuggeeKilled");
  182. // WaitForPause(PausedReason.Break);
  183. // Assert.AreNotEqual(null, lastLogMessage);
  184. // System.Diagnostics.Process p = System.Diagnostics.Process.GetProcessById(int.Parse(lastLogMessage));
  185. // p.Kill();
  186. // debugger.WaitForPrecessExit();
  187. // }
  188. //
  189. // [Test]
  190. // public void Stepping()
  191. // {
  192. // StartProgram("Stepping");
  193. // WaitForPause(PausedReason.Break, null);
  194. //
  195. // debugger.StepOver(); // Debugger.Break
  196. // WaitForPause(PausedReason.StepComplete, null);
  197. //
  198. // debugger.StepOver(); // Debug.WriteLine 1
  199. // WaitForPause(PausedReason.StepComplete, "1");
  200. //
  201. // debugger.StepInto(); // Method Sub
  202. // WaitForPause(PausedReason.StepComplete, "1");
  203. //
  204. // debugger.StepInto(); // '{'
  205. // WaitForPause(PausedReason.StepComplete, "1");
  206. //
  207. // debugger.StepInto(); // Debug.WriteLine 2
  208. // WaitForPause(PausedReason.StepComplete, "2");
  209. //
  210. // debugger.StepOut(); // Method Sub
  211. // WaitForPause(PausedReason.StepComplete, "4");
  212. //
  213. // debugger.StepOver(); // Method Sub
  214. // WaitForPause(PausedReason.StepComplete, "4");
  215. //
  216. // debugger.StepOver(); // Method Sub2
  217. // WaitForPause(PausedReason.StepComplete, "5");
  218. //
  219. // debugger.Continue();
  220. // debugger.WaitForPrecessExit();
  221. // }
  222. //
  223. // [Test]
  224. // public void Callstack()
  225. // {
  226. // List<Function> callstack;
  227. //
  228. // StartProgram("Callstack");
  229. // WaitForPause(PausedReason.Break, null);
  230. // callstack = new List<Function>(debugger.SelectedThread.Callstack);
  231. // Assert.AreEqual("Sub2", callstack[0].Name);
  232. // Assert.AreEqual("Sub1", callstack[1].Name);
  233. // Assert.AreEqual("Main", callstack[2].Name);
  234. //
  235. // debugger.StepOut();
  236. // WaitForPause(PausedReason.StepComplete, null);
  237. // callstack = new List<Function>(debugger.SelectedThread.Callstack);
  238. // Assert.AreEqual("Sub1", callstack[0].Name);
  239. // Assert.AreEqual("Main", callstack[1].Name);
  240. //
  241. // debugger.StepOut();
  242. // WaitForPause(PausedReason.StepComplete, null);
  243. // callstack = new List<Function>(debugger.SelectedThread.Callstack);
  244. // Assert.AreEqual("Main", callstack[0].Name);
  245. //
  246. // debugger.Continue();
  247. // debugger.WaitForPrecessExit();
  248. // }
  249. //
  250. // [Test]
  251. // public void FunctionArgumentVariables()
  252. // {
  253. // List<Variable> args;
  254. //
  255. // StartProgram("FunctionArgumentVariables");
  256. // WaitForPause(PausedReason.Break, null);
  257. //
  258. // for(int i = 0; i < 2; i++) {
  259. // debugger.Continue();
  260. // WaitForPause(PausedReason.Break, null);
  261. // args = new List<Variable>(debugger.SelectedFunction.ArgumentVariables);
  262. // // names
  263. // Assert.AreEqual("i", args[0].Name);
  264. // Assert.AreEqual("s", args[1].Name);
  265. // Assert.AreEqual("args", args[2].Name);
  266. // // types
  267. // Assert.AreEqual(typeof(PrimitiveValue), args[0].Value.GetType());
  268. // Assert.AreEqual(typeof(PrimitiveValue), args[1].Value.GetType());
  269. // Assert.AreEqual(typeof(ArrayValue),     args[2].Value.GetType());
  270. // // values
  271. // Assert.AreEqual("0", args[0].Value.AsString);
  272. // Assert.AreEqual("S", args[1].Value.AsString);
  273. // Assert.AreEqual(0 ,((ArrayValue)args[2].Value).Lenght);
  274. //
  275. // debugger.Continue();
  276. // WaitForPause(PausedReason.Break, null);
  277. // args = new List<Variable>(debugger.SelectedFunction.ArgumentVariables);
  278. // // types
  279. // Assert.AreEqual(typeof(PrimitiveValue), args[0].Value.GetType());
  280. // Assert.AreEqual(typeof(PrimitiveValue), args[1].Value.GetType());
  281. // Assert.AreEqual(typeof(ArrayValue),     args[2].Value.GetType());
  282. // // values
  283. // Assert.AreEqual("1", args[0].Value.AsString);
  284. // Assert.AreEqual("S", args[1].Value.AsString);
  285. // Assert.AreEqual(1 ,((ArrayValue)args[2].Value).Lenght);
  286. //
  287. // debugger.Continue();
  288. // WaitForPause(PausedReason.Break, null);
  289. // args = new List<Variable>(debugger.SelectedFunction.ArgumentVariables);
  290. // // types
  291. // Assert.AreEqual(typeof(PrimitiveValue), args[0].Value.GetType());
  292. // Assert.AreEqual(typeof(NullValue), args[1].Value.GetType());
  293. // Assert.AreEqual(typeof(ArrayValue),     args[2].Value.GetType());
  294. // // values
  295. // Assert.AreEqual("2", args[0].Value.AsString);
  296. // Assert.IsNotNull(args[1].Value.AsString);
  297. // Assert.AreEqual(2 ,((ArrayValue)args[2].Value).Lenght);
  298. // }
  299. //
  300. // debugger.Continue();
  301. // debugger.WaitForPrecessExit();
  302. // }
  303. //
  304. // [Test]
  305. // public void FunctionLocalVariables()
  306. // {
  307. // List<Variable> args;
  308. //
  309. // StartProgram("FunctionLocalVariables");
  310. // WaitForPause(PausedReason.Break, null);
  311. // args = new List<Variable>(debugger.SelectedFunction.LocalVariables);
  312. // // names
  313. // Assert.AreEqual("i", args[0].Name);
  314. // Assert.AreEqual("s", args[1].Name);
  315. // Assert.AreEqual("args", args[2].Name);
  316. // Assert.AreEqual("n", args[3].Name);
  317. // Assert.AreEqual("o", args[4].Name);
  318. // // types
  319. // Assert.AreEqual(typeof(PrimitiveValue), args[0].Value.GetType());
  320. // Assert.AreEqual(typeof(PrimitiveValue), args[1].Value.GetType());
  321. // Assert.AreEqual(typeof(ArrayValue),     args[2].Value.GetType());
  322. // Assert.AreEqual(typeof(NullValue),     args[3].Value.GetType());
  323. // Assert.AreEqual(typeof(ObjectValue),     args[4].Value.GetType());
  324. // // values
  325. // Assert.AreEqual("0", args[0].Value.AsString);
  326. // Assert.AreEqual("S", args[1].Value.AsString);
  327. // Assert.AreEqual(1 ,((ArrayValue)args[2].Value).Lenght);
  328. // Assert.IsNotNull(args[3].Value.AsString);
  329. // Assert.AreEqual("{System.Object}", args[4].Value.AsString);
  330. //
  331. // debugger.Continue();
  332. // debugger.WaitForPrecessExit();
  333. // }
  334. //
  335. // [Test]
  336. // public void FunctionLifetime()
  337. // {
  338. // Function function;
  339. //
  340. // StartProgram("FunctionLifetime");
  341. // WaitForPause(PausedReason.Break, null);
  342. // function = debugger.SelectedFunction;
  343. // Assert.IsNotNull(function);
  344. // Assert.AreEqual("Function", function.Name);
  345. // Assert.AreEqual(false, function.HasExpired);
  346. // Assert.AreEqual("1", function.GetArgumentVariable(0).Value.AsString);
  347. //
  348. // debugger.Continue(); // Go to the SubFunction
  349. // WaitForPause(PausedReason.Break, null);
  350. // Assert.AreEqual("SubFunction", debugger.SelectedFunction.Name);
  351. // Assert.AreEqual(false, function.HasExpired);
  352. // Assert.AreEqual("1", function.GetArgumentVariable(0).Value.AsString);
  353. //
  354. // debugger.Continue(); // Go back to Function
  355. // WaitForPause(PausedReason.Break, null);
  356. // Assert.AreEqual("Function", debugger.SelectedFunction.Name);
  357. // Assert.AreEqual(false, function.HasExpired);
  358. // Assert.AreEqual("1", function.GetArgumentVariable(0).Value.AsString);
  359. //
  360. // debugger.Continue(); // Setp out of function
  361. // WaitForPause(PausedReason.Break, null);
  362. // Assert.AreEqual("Main", debugger.SelectedFunction.Name);
  363. // Assert.AreEqual(true, function.HasExpired);
  364. //
  365. // debugger.Continue();
  366. // debugger.WaitForPrecessExit();
  367. // }
  368. //
  369. // [Test]
  370. // public void FunctionVariablesLifetime()
  371. // {
  372. // Function function = null;
  373. // Variable argument = null;
  374. // Variable local    = null;
  375. // Variable localInSubFunction = null;
  376. // Variable @class   = null;
  377. //
  378. // StartProgram("FunctionVariablesLifetime"); // 1 - Enter program
  379. // WaitForPause(PausedReason.Break, null);
  380. // function = debugger.SelectedFunction;
  381. // Assert.IsNotNull(function);
  382. // Assert.AreEqual("Function", function.Name);
  383. // argument = function.GetArgumentVariable(0);
  384. // foreach(Variable var in function.LocalVariables) {
  385. // local = var;
  386. // }
  387. // foreach(Variable var in function.ContaingClassVariables) {
  388. // @class = var;
  389. // }
  390. // Assert.IsNotNull(argument);
  391. // Assert.IsNotNull(local);
  392. // Assert.IsNotNull(@class);
  393. // Assert.AreEqual("argument", argument.Name);
  394. // Assert.AreEqual("local", local.Name);
  395. // Assert.AreEqual("class", @class.Name);
  396. // Assert.AreEqual("1", argument.Value.AsString);
  397. // Assert.AreEqual("2", local.Value.AsString);
  398. // Assert.AreEqual("3", @class.Value.AsString);
  399. //
  400. // debugger.Continue(); // 2 - Go to the SubFunction
  401. // WaitForPause(PausedReason.Break, null);
  402. // Assert.AreEqual("1", argument.Value.AsString);
  403. // Assert.AreEqual("2", local.Value.AsString);
  404. // Assert.AreEqual("3", @class.Value.AsString);
  405. // // Check localInSubFunction variable
  406. // localInSubFunction = debugger.LocalVariables["localInSubFunction"];
  407. // Assert.AreEqual("4", localInSubFunction.Value.AsString);
  408. //
  409. // debugger.Continue(); // 3 - Go back to Function
  410. // WaitForPause(PausedReason.Break, null);
  411. // Assert.AreEqual("1", argument.Value.AsString);
  412. // Assert.AreEqual("2", local.Value.AsString);
  413. // Assert.AreEqual("3", @class.Value.AsString);
  414. // // localInSubFunction should be dead now
  415. // Assert.AreEqual(typeof(UnavailableValue), localInSubFunction.Value.GetType());
  416. //
  417. // debugger.Continue(); // 4 - Go to the SubFunction
  418. // WaitForPause(PausedReason.Break, null);
  419. // Assert.AreEqual("1", argument.Value.AsString);
  420. // Assert.AreEqual("2", local.Value.AsString);
  421. // Assert.AreEqual("3", @class.Value.AsString);
  422. // // localInSubFunction should be still dead...
  423. // Assert.AreEqual(typeof(UnavailableValue), localInSubFunction.Value.GetType());
  424. // // ... , but we should able to get new one
  425. // localInSubFunction = debugger.LocalVariables["localInSubFunction"];
  426. // Assert.AreEqual("4", localInSubFunction.Value.AsString);
  427. //
  428. // debugger.Continue(); // 5 - Setp out of both functions
  429. // WaitForPause(PausedReason.Break, null);
  430. // Assert.AreEqual(typeof(UnavailableValue), argument.Value.GetType());
  431. // Assert.AreEqual(typeof(UnavailableValue), local.Value.GetType());
  432. // Assert.AreEqual(typeof(UnavailableValue), @class.Value.GetType());
  433. //
  434. // debugger.Continue();
  435. // debugger.WaitForPrecessExit();
  436. // }
  437. //
  438. // [Test]
  439. // public void ArrayValue()
  440. // {
  441. // Variable local = null;
  442. // List<Variable> subVars = new List<Variable>();
  443. //
  444. // StartProgram("ArrayValue");
  445. // WaitForPause(PausedReason.Break, null);
  446. // foreach(Variable var in debugger.SelectedFunction.LocalVariables) {
  447. // local = var; break;
  448. // }
  449. // Assert.AreEqual("array", local.Name);
  450. // Assert.AreEqual(true, local.Value.MayHaveSubVariables);
  451. // Assert.AreEqual(typeof(ArrayValue), local.Value.GetType());
  452. // Assert.AreEqual("{System.Int32[5]}", local.Value.AsString);
  453. // foreach(Variable var in local.Value.SubVariables) {
  454. // subVars.Add(var);
  455. // }
  456. // for(int i = 0; i < 5; i++) {
  457. // Assert.AreEqual("[" + i.ToString() + "]", subVars[i].Name);
  458. // Assert.AreEqual(i.ToString(), subVars[i].Value.AsString);
  459. // }
  460. //
  461. // debugger.Continue();
  462. // debugger.WaitForPrecessExit();
  463. // }
  464. //
  465. // [Test]
  466. // public void ObjectValue()
  467. // {
  468. // Variable local = null;
  469. // Variable baseClass;
  470. // List<Variable> subVars = new List<Variable>();
  471. //
  472. // StartProgram("ObjectValue");
  473. // WaitForPause(PausedReason.Break, null);
  474. // foreach(Variable var in debugger.SelectedFunction.LocalVariables) {
  475. // local = var;
  476. // }
  477. // Assert.AreEqual("val", local.Name);
  478. // Assert.AreEqual(true, local.Value.MayHaveSubVariables);
  479. // Assert.AreEqual(typeof(ObjectValue), local.Value.GetType());
  480. // Assert.AreEqual("{Debugger.Tests.TestPrograms.ObjectValue}", local.Value.AsString);
  481. // foreach(Variable var in local.Value.SubVariables) {
  482. // subVars.Add(var);
  483. // }
  484. // Assert.AreEqual("privateField", subVars[1].Name);
  485. // Assert.AreEqual("publicFiled", subVars[2].Name);
  486. // Assert.AreEqual("PublicProperty", subVars[3].Name);
  487. // Assert.AreEqual(typeof(Variable), subVars[1].GetType());
  488. // Assert.AreEqual(typeof(Variable), subVars[2].GetType());
  489. // Assert.AreEqual(typeof(Variable), subVars[3].GetType());
  490. // Assert.AreEqual(false, ((Variable)subVars[1]).IsPublic);
  491. // Assert.AreEqual(true, ((Variable)subVars[2]).IsPublic);
  492. // Assert.AreEqual(true, ((Variable)subVars[3]).IsPublic);
  493. // baseClass = subVars[0];
  494. // Assert.AreEqual(typeof(ObjectValue), baseClass.Value.GetType());
  495. // Assert.AreEqual("{Debugger.Tests.TestPrograms.BaseClass}", baseClass.Value.AsString);
  496. //
  497. // debugger.Continue();
  498. // WaitForPause(PausedReason.Break, null);
  499. // Assert.AreEqual(typeof(ObjectValue), baseClass.Value.GetType());
  500. // Assert.AreEqual("{Debugger.Tests.TestPrograms.BaseClass}", baseClass.Value.AsString);
  501. //
  502. // debugger.Continue();
  503. // debugger.WaitForPrecessExit();
  504. // }
  505. //
  506. // [Test]
  507. // public void PropertyVariable()
  508. // {
  509. // Variable local = null;
  510. // List<Variable> subVars = new List<Variable>();
  511. //
  512. // StartProgram("PropertyVariable");
  513. // WaitForPause(PausedReason.Break, null);
  514. // foreach(Variable var in debugger.SelectedFunction.LocalVariables) {
  515. // local = var;
  516. // }
  517. // foreach(Variable var in local.Value.SubVariables) {
  518. // subVars.Add(var);
  519. // }
  520. // Assert.AreEqual("PrivateProperty", subVars[1].Name);
  521. // Assert.AreEqual("PublicProperty", subVars[2].Name);
  522. // Assert.AreEqual("ExceptionProperty", subVars[3].Name);
  523. // Assert.AreEqual("StaticProperty", subVars[4].Name);
  524. //
  525. // Assert.AreEqual(typeof(UnavailableValue), subVars[1].Value.GetType());
  526. // debugger.StartEvaluation();
  527. // WaitForPause(PausedReason.EvalComplete, null);
  528. // Assert.AreEqual("private", subVars[1].Value.AsString);
  529. //
  530. // Assert.AreEqual(typeof(UnavailableValue), subVars[2].Value.GetType());
  531. // debugger.StartEvaluation();
  532. // WaitForPause(PausedReason.EvalComplete, null);
  533. // Assert.AreEqual("public", subVars[2].Value.AsString);
  534. //
  535. // Assert.AreEqual(typeof(UnavailableValue), subVars[3].Value.GetType());
  536. // debugger.StartEvaluation();
  537. // WaitForPause(PausedReason.EvalComplete, null);
  538. // Assert.AreEqual(typeof(UnavailableValue), subVars[3].Value.GetType());
  539. //
  540. // Assert.AreEqual(typeof(UnavailableValue), subVars[4].Value.GetType());
  541. // debugger.StartEvaluation();
  542. // WaitForPause(PausedReason.EvalComplete, null);
  543. // Assert.AreEqual("static", subVars[4].Value.AsString);
  544. //
  545. // debugger.Continue();
  546. // WaitForPause(PausedReason.Break, null);
  547. //
  548. // debugger.Continue();
  549. // debugger.WaitForPrecessExit();
  550. // }
  551. //
  552. // [Test]
  553. // public void PropertyVariableForm()
  554. // {
  555. // Variable local = null;
  556. //
  557. // StartProgram("PropertyVariableForm");
  558. // WaitForPause(PausedReason.Break, null);
  559. // foreach(Variable var in debugger.SelectedFunction.LocalVariables) {
  560. // local = var;
  561. // }
  562. // Assert.AreEqual("form", local.Name);
  563. // Assert.AreEqual(typeof(Variable), local.GetType());
  564. //
  565. // foreach(Variable var in local.Value.SubVariables) {
  566. // Assert.AreEqual(typeof(UnavailableValue), var.Value.GetType(), "Variable name: " + var.Name);
  567. // debugger.StartEvaluation();
  568. // WaitForPause(PausedReason.EvalComplete, null);
  569. // Assert.AreNotEqual(null, var.Value.AsString, "Variable name: " + var.Name);
  570. // }
  571. //
  572. // debugger.Continue();
  573. // WaitForPause(PausedReason.Break, null);
  574. //
  575. // foreach(Variable var in local.Value.SubVariables) {
  576. // Assert.AreEqual(typeof(UnavailableValue), var.Value.GetType(), "Variable name: " + var.Name);
  577. // }
  578. // debugger.StartEvaluation();
  579. // WaitForPause(PausedReason.EvalComplete, null);
  580. //
  581. // debugger.Continue();
  582. // debugger.WaitForPrecessExit();
  583. // }
  584. //
  585. // [Test]
  586. // public void SetIP()
  587. // {
  588. // StartProgram("SetIP");
  589. // WaitForPause(PausedReason.Break, "1");
  590. //
  591. // Assert.IsNotNull(debugger.SelectedFunction.CanSetIP("SetIP.cs", 16, 0));
  592. // Assert.IsNull(debugger.SelectedFunction.CanSetIP("SetIP.cs", 100, 0));
  593. // debugger.SelectedFunction.SetIP("SetIP.cs", 16, 0);
  594. // debugger.Continue();
  595. // WaitForPause(PausedReason.Break, "1");
  596. // Assert.AreEqual("1rn1rn", log);
  597. //
  598. // debugger.Continue();
  599. // debugger.WaitForPrecessExit();
  600. // }
  601. }
  602. }