PageRenderTime 57ms CodeModel.GetById 28ms RepoModel.GetById 0ms app.codeStats 1ms

/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/ParameterCompletionTests.cs

https://github.com/EdwardWu99/ILSpy
C# | 981 lines | 834 code | 79 blank | 68 comment | 16 complexity | ce19e4d1aa0e80b11d346dd106bd0816 MD5 | raw file
Possible License(s): CC-BY-SA-3.0
  1. //
  2. // ParameterCompletionTests.cs
  3. //
  4. // Author:
  5. // Mike Krüger <mkrueger@novell.com>
  6. //
  7. // Copyright (C) 2008 Novell, Inc (http://www.novell.com)
  8. //
  9. // Permission is hereby granted, free of charge, to any person obtaining
  10. // a copy of this software and associated documentation files (the
  11. // "Software"), to deal in the Software without restriction, including
  12. // without limitation the rights to use, copy, modify, merge, publish,
  13. // distribute, sublicense, and/or sell copies of the Software, and to
  14. // permit persons to whom the Software is furnished to do so, subject to
  15. // the following conditions:
  16. //
  17. // The above copyright notice and this permission notice shall be
  18. // included in all copies or substantial portions of the Software.
  19. //
  20. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24. // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25. // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27. //
  28. using System;
  29. using System.Collections.Generic;
  30. using NUnit.Framework;
  31. using ICSharpCode.NRefactory.Completion;
  32. using ICSharpCode.NRefactory.CSharp.Completion;
  33. using ICSharpCode.NRefactory.Editor;
  34. using ICSharpCode.NRefactory.TypeSystem.Implementation;
  35. using ICSharpCode.NRefactory.TypeSystem;
  36. using System.Linq;
  37. using ICSharpCode.NRefactory.CSharp.TypeSystem;
  38. namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
  39. {
  40. [TestFixture()]
  41. public class ParameterCompletionTests : TestBase
  42. {
  43. class TestFactory : IParameterCompletionDataFactory
  44. {
  45. IProjectContent ctx;
  46. public TestFactory (IProjectContent ctx)
  47. {
  48. this.ctx = ctx;
  49. }
  50. class Provider : IParameterDataProvider
  51. {
  52. public IEnumerable<IMethod> Data { get; set; }
  53. #region IParameterDataProvider implementation
  54. public int StartOffset { get { return 0; } }
  55. public string GetHeading (int overload, string[] parameterDescription, int currentParameter)
  56. {
  57. return "";
  58. }
  59. public string GetDescription (int overload, int currentParameter)
  60. {
  61. return "";
  62. }
  63. public string GetParameterDescription (int overload, int paramIndex)
  64. {
  65. return "";
  66. }
  67. public int GetParameterCount (int overload)
  68. {
  69. var method = Data.ElementAt (overload);
  70. return method.Parameters.Count;
  71. }
  72. public bool AllowParameterList (int overload)
  73. {
  74. return false;
  75. }
  76. public int Count {
  77. get {
  78. return Data.Count ();
  79. }
  80. }
  81. #endregion
  82. }
  83. class IndexerProvider : IParameterDataProvider
  84. {
  85. public IEnumerable<IProperty> Data { get; set; }
  86. #region IParameterDataProvider implementation
  87. public int StartOffset { get { return 0; } }
  88. public string GetHeading (int overload, string[] parameterDescription, int currentParameter)
  89. {
  90. return "";
  91. }
  92. public string GetDescription (int overload, int currentParameter)
  93. {
  94. return "";
  95. }
  96. public string GetParameterDescription (int overload, int paramIndex)
  97. {
  98. return "";
  99. }
  100. public int GetParameterCount (int overload)
  101. {
  102. var method = Data.ElementAt (overload);
  103. return method.Parameters.Count;
  104. }
  105. public bool AllowParameterList (int overload)
  106. {
  107. return false;
  108. }
  109. public int Count {
  110. get {
  111. return Data.Count ();
  112. }
  113. }
  114. #endregion
  115. }
  116. class ArrayProvider : IParameterDataProvider
  117. {
  118. #region IParameterDataProvider implementation
  119. public int StartOffset { get { return 0; } }
  120. public string GetHeading (int overload, string[] parameterDescription, int currentParameter)
  121. {
  122. return "";
  123. }
  124. public string GetDescription (int overload, int currentParameter)
  125. {
  126. return "";
  127. }
  128. public string GetParameterDescription (int overload, int paramIndex)
  129. {
  130. return "";
  131. }
  132. public int GetParameterCount (int overload)
  133. {
  134. return 1;
  135. }
  136. public bool AllowParameterList (int overload)
  137. {
  138. return false;
  139. }
  140. public int Count {
  141. get {
  142. return 1;
  143. }
  144. }
  145. #endregion
  146. }
  147. class TypeParameterDataProvider : IParameterDataProvider
  148. {
  149. public IEnumerable<IType> Data { get; set; }
  150. #region IParameterDataProvider implementation
  151. public int StartOffset { get { return 0; } }
  152. public string GetHeading (int overload, string[] parameterDescription, int currentParameter)
  153. {
  154. return "";
  155. }
  156. public string GetDescription (int overload, int currentParameter)
  157. {
  158. return "";
  159. }
  160. public string GetParameterDescription (int overload, int paramIndex)
  161. {
  162. return "";
  163. }
  164. public int GetParameterCount (int overload)
  165. {
  166. var data = Data.ElementAt (overload);
  167. return data.TypeParameterCount;
  168. }
  169. public bool AllowParameterList (int overload)
  170. {
  171. return false;
  172. }
  173. public int Count {
  174. get {
  175. return Data.Count ();
  176. }
  177. }
  178. #endregion
  179. }
  180. #region IParameterCompletionDataFactory implementation
  181. public IParameterDataProvider CreateConstructorProvider(int startOffset, ICSharpCode.NRefactory.TypeSystem.IType type)
  182. {
  183. Assert.IsTrue(type.Kind != TypeKind.Unknown);
  184. return new Provider () {
  185. Data = type.GetConstructors (m => m.Accessibility == Accessibility.Public)
  186. };
  187. }
  188. public IParameterDataProvider CreateMethodDataProvider (int startOffset, IEnumerable<IMethod> methods)
  189. {
  190. return new Provider () {
  191. Data = methods
  192. };
  193. }
  194. public IParameterDataProvider CreateDelegateDataProvider(int startOffset, ICSharpCode.NRefactory.TypeSystem.IType type)
  195. {
  196. Assert.IsTrue(type.Kind != TypeKind.Unknown);
  197. return new Provider () {
  198. Data = new [] { type.GetDelegateInvokeMethod () }
  199. };
  200. }
  201. public IParameterDataProvider CreateIndexerParameterDataProvider(int startOffset, IType type, AstNode resolvedNode)
  202. {
  203. Assert.IsTrue(type.Kind != TypeKind.Unknown);
  204. if (type.Kind == TypeKind.Array)
  205. return new ArrayProvider ();
  206. return new IndexerProvider () {
  207. Data = type.GetProperties (p => p.IsIndexer)
  208. };
  209. }
  210. public IParameterDataProvider CreateTypeParameterDataProvider (int startOffset, IEnumerable<IType> types)
  211. {
  212. return new TypeParameterDataProvider () {
  213. Data = types
  214. };
  215. }
  216. #endregion
  217. }
  218. internal static IParameterDataProvider CreateProvider(string text)
  219. {
  220. string parsedText;
  221. string editorText;
  222. int cursorPosition = text.IndexOf('$');
  223. int endPos = text.IndexOf('$', cursorPosition + 1);
  224. if (endPos == -1) {
  225. parsedText = editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1);
  226. } else {
  227. parsedText = text.Substring(0, cursorPosition) + new string(' ', endPos - cursorPosition) + text.Substring(endPos + 1);
  228. editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1, endPos - cursorPosition - 1) + text.Substring(endPos + 1);
  229. cursorPosition = endPos - 1;
  230. }
  231. var doc = new ReadOnlyDocument(editorText);
  232. IProjectContent pctx = new CSharpProjectContent();
  233. pctx = pctx.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
  234. var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
  235. syntaxTree.Freeze();
  236. var unresolvedFile = syntaxTree.ToTypeSystem();
  237. pctx = pctx.AddOrUpdateFiles(unresolvedFile);
  238. var cmp = pctx.CreateCompilation();
  239. var loc = doc.GetLocation(cursorPosition);
  240. var rctx = new CSharpTypeResolveContext(cmp.MainAssembly);
  241. rctx = rctx.WithUsingScope(unresolvedFile.GetUsingScope(loc).Resolve(cmp));
  242. var curDef = unresolvedFile.GetInnermostTypeDefinition(loc);
  243. if (curDef != null) {
  244. rctx = rctx.WithCurrentTypeDefinition(curDef.Resolve(rctx).GetDefinition());
  245. var curMember = unresolvedFile.GetMember(loc);
  246. if (curMember != null) {
  247. rctx = rctx.WithCurrentMember(curMember.CreateResolved(rctx));
  248. }
  249. }
  250. var mb = new DefaultCompletionContextProvider(doc, unresolvedFile);
  251. var engine = new CSharpParameterCompletionEngine (doc, mb, new TestFactory (pctx), pctx, rctx);
  252. return engine.GetParameterDataProvider (cursorPosition, doc.GetCharAt (cursorPosition - 1));
  253. }
  254. /// <summary>
  255. /// Bug 427448 - Code Completion: completion of constructor parameters not working
  256. /// </summary>
  257. [Test()]
  258. public void TestBug427448 ()
  259. {
  260. IParameterDataProvider provider = CreateProvider (
  261. @"class Test
  262. {
  263. public Test (int a)
  264. {
  265. }
  266. public Test (string b)
  267. {
  268. }
  269. protected Test ()
  270. {
  271. }
  272. Test (double d, float m)
  273. {
  274. }
  275. }
  276. class AClass
  277. {
  278. void A()
  279. {
  280. $Test t = new Test ($
  281. }
  282. }");
  283. Assert.IsNotNull (provider, "provider was not created.");
  284. Assert.AreEqual (2, provider.Count);
  285. }
  286. /// <summary>
  287. /// Bug 432437 - No completion when invoking delegates
  288. /// </summary>
  289. [Test()]
  290. public void TestBug432437 ()
  291. {
  292. IParameterDataProvider provider = CreateProvider (
  293. @"public delegate void MyDel (int value);
  294. class Test
  295. {
  296. MyDel d;
  297. void A()
  298. {
  299. $d ($
  300. }
  301. }");
  302. Assert.IsNotNull (provider, "provider was not created.");
  303. Assert.AreEqual (1, provider.Count);
  304. }
  305. /// <summary>
  306. /// Bug 432658 - Incorrect completion when calling an extension method from inside another extension method
  307. /// </summary>
  308. [Test()]
  309. public void TestBug432658 ()
  310. {
  311. IParameterDataProvider provider = CreateProvider (
  312. @"static class Extensions
  313. {
  314. public static void Ext1 (this int start)
  315. {
  316. }
  317. public static void Ext2 (this int end)
  318. {
  319. $Ext1($
  320. }
  321. }");
  322. Assert.IsNotNull (provider, "provider was not created.");
  323. Assert.AreEqual (1, provider.Count, "There should be one overload");
  324. Assert.AreEqual (1, provider.GetParameterCount(0), "Parameter 'start' should exist");
  325. }
  326. /// <summary>
  327. /// Bug 432727 - No completion if no constructor
  328. /// </summary>
  329. [Test()]
  330. public void TestBug432727 ()
  331. {
  332. IParameterDataProvider provider = CreateProvider (
  333. @"class A
  334. {
  335. void Method ()
  336. {
  337. $A aTest = new A ($
  338. }
  339. }");
  340. Assert.IsNotNull (provider, "provider was not created.");
  341. Assert.AreEqual (1, provider.Count);
  342. }
  343. /// <summary>
  344. /// Bug 434705 - No autocomplete offered if not assigning result of 'new' to a variable
  345. /// </summary>
  346. [Test()]
  347. public void TestBug434705 ()
  348. {
  349. IParameterDataProvider provider = CreateProvider (
  350. @"class Test
  351. {
  352. public Test (int a)
  353. {
  354. }
  355. }
  356. class AClass
  357. {
  358. Test A()
  359. {
  360. $return new Test ($
  361. }
  362. }");
  363. Assert.IsNotNull (provider, "provider was not created.");
  364. Assert.AreEqual (1, provider.Count);
  365. }
  366. /// <summary>
  367. /// Bug 434705 - No autocomplete offered if not assigning result of 'new' to a variable
  368. /// </summary>
  369. [Test()]
  370. public void TestBug434705B ()
  371. {
  372. IParameterDataProvider provider = CreateProvider (
  373. @"
  374. class Test<T>
  375. {
  376. public Test (T t)
  377. {
  378. }
  379. }
  380. class TestClass
  381. {
  382. void TestMethod ()
  383. {
  384. $Test<int> l = new Test<int> ($
  385. }
  386. }");
  387. Assert.IsNotNull (provider, "provider was not created.");
  388. Assert.AreEqual (1, provider.Count);
  389. }
  390. /// <summary>
  391. /// Bug 434701 - No autocomplete in attributes
  392. /// </summary>
  393. [Test()]
  394. public void TestBug434701 ()
  395. {
  396. IParameterDataProvider provider = CreateProvider (
  397. @"namespace Test {
  398. class TestAttribute : System.Attribute
  399. {
  400. public Test (int a)
  401. {
  402. }
  403. }
  404. $[Test ($
  405. class AClass
  406. {
  407. }
  408. }");
  409. Assert.IsNotNull (provider, "provider was not created.");
  410. Assert.AreEqual (1, provider.Count);
  411. }
  412. /// <summary>
  413. /// Bug 447985 - Exception display tip is inaccurate for derived (custom) exceptions
  414. /// </summary>
  415. [Test()]
  416. public void TestBug447985 ()
  417. {
  418. IParameterDataProvider provider = CreateProvider (
  419. @"
  420. namespace System {
  421. public class Exception
  422. {
  423. public Exception () {}
  424. }
  425. }
  426. class MyException : System.Exception
  427. {
  428. public MyException (int test)
  429. {}
  430. }
  431. class AClass
  432. {
  433. public void Test ()
  434. {
  435. $throw new MyException($
  436. }
  437. }");
  438. Assert.IsNotNull (provider, "provider was not created.");
  439. Assert.AreEqual (1, provider.Count);
  440. Assert.AreEqual (1, provider.GetParameterCount(0), "Parameter 'test' should exist");
  441. }
  442. /// <summary>
  443. /// Bug 1760 - [New Resolver] Parameter tooltip not shown for indexers
  444. /// </summary>
  445. [Test()]
  446. public void Test1760 ()
  447. {
  448. var provider = CreateProvider (
  449. @"
  450. class TestClass
  451. {
  452. public static void Main (string[] args)
  453. {
  454. $args[$
  455. }
  456. }");
  457. Assert.IsNotNull (provider, "provider was not created.");
  458. Assert.AreEqual (1, provider.Count);
  459. }
  460. [Test()]
  461. public void TestSecondIndexerParameter ()
  462. {
  463. var provider = CreateProvider (
  464. @"
  465. class TestClass
  466. {
  467. public int this[int i, int j] { get { return 0; } }
  468. public void Test ()
  469. {
  470. $this[1,$
  471. }
  472. }");
  473. Assert.IsNotNull (provider, "provider was not created.");
  474. Assert.AreEqual (1, provider.Count);
  475. }
  476. [Test()]
  477. public void TestSecondMethodParameter ()
  478. {
  479. var provider = CreateProvider (
  480. @"
  481. class TestClass
  482. {
  483. public int TestMe (int i, int j) { return 0; }
  484. public void Test ()
  485. {
  486. $TestMe (1,$
  487. }
  488. }");
  489. Assert.IsNotNull (provider, "provider was not created.");
  490. Assert.AreEqual (1, provider.Count);
  491. }
  492. /// Bug 599 - Regression: No intellisense over Func delegate
  493. [Test()]
  494. public void TestBug599 ()
  495. {
  496. var provider = CreateProvider (
  497. @"using System;
  498. using System.Core;
  499. class TestClass
  500. {
  501. void A (Func<int, int> f)
  502. {
  503. $f ($
  504. }
  505. }");
  506. Assert.IsNotNull (provider, "provider was not created.");
  507. Assert.AreEqual (1, provider.Count);
  508. }
  509. /// Bug 3307 - Chained linq methods do not work correctly
  510. [Test()]
  511. public void TestBug3307 ()
  512. {
  513. var provider = CreateProvider (
  514. @"using System;
  515. using System.Linq;
  516. class TestClass
  517. {
  518. public static void Main (string[] args)
  519. {
  520. $args.Select ($
  521. }
  522. }");
  523. Assert.IsNotNull (provider, "provider was not created.");
  524. Assert.IsTrue (provider.Count > 0);
  525. }
  526. [Test()]
  527. public void TestBug3307FollowUp ()
  528. {
  529. var provider = CodeCompletionBugTests.CreateProvider (
  530. @"using System;
  531. using System.Linq;
  532. public class MainClass
  533. {
  534. static void TestMe (Action<int> act)
  535. {
  536. }
  537. public static void Main (string[] args)
  538. {
  539. $TestMe (x$
  540. }
  541. }");
  542. Assert.IsNotNull (provider, "provider was not created.");
  543. Assert.IsFalse (provider.AutoSelect, "auto select enabled !");
  544. }
  545. [Test()]
  546. public void TestBug3307FollowUp2 ()
  547. {
  548. var provider = CodeCompletionBugTests.CreateProvider (
  549. @"using System;
  550. using System.Linq;
  551. public class MainClass
  552. {
  553. public static void Main (string[] args)
  554. {
  555. $args.Select (x$
  556. }
  557. }");
  558. Assert.IsNotNull (provider, "provider was not created.");
  559. Assert.IsFalse (provider.AutoSelect, "auto select enabled !");
  560. }
  561. [Test()]
  562. public void TestConstructor ()
  563. {
  564. IParameterDataProvider provider = CreateProvider (
  565. @"class Foo { public Foo (int a) {} }
  566. class A
  567. {
  568. void Method ()
  569. {
  570. $Bar = new Foo ($
  571. }
  572. }");
  573. Assert.IsNotNull (provider, "provider was not created.");
  574. Assert.AreEqual (1, provider.Count);
  575. }
  576. [Test()]
  577. public void TestConstructorCase2 ()
  578. {
  579. IParameterDataProvider provider = CreateProvider (
  580. @"
  581. namespace Test
  582. {
  583. struct TestMe
  584. {
  585. public TestMe (string a)
  586. {
  587. }
  588. }
  589. class A
  590. {
  591. void Method ()
  592. {
  593. $new TestMe ($
  594. }
  595. }
  596. }");
  597. Assert.IsNotNull (provider, "provider was not created.");
  598. Assert.AreEqual (2, provider.Count);
  599. }
  600. [Test()]
  601. public void TestTypeParameter ()
  602. {
  603. IParameterDataProvider provider = CreateProvider (
  604. @"using System;
  605. namespace Test
  606. {
  607. class A
  608. {
  609. void Method ()
  610. {
  611. $Action<$
  612. }
  613. }
  614. }");
  615. Assert.IsNotNull (provider, "provider was not created.");
  616. Assert.AreEqual (16, provider.Count);
  617. }
  618. [Test()]
  619. public void TestSecondTypeParameter ()
  620. {
  621. IParameterDataProvider provider = CreateProvider (
  622. @"using System;
  623. namespace Test
  624. {
  625. class A
  626. {
  627. void Method ()
  628. {
  629. $Action<string,$
  630. }
  631. }
  632. }");
  633. Assert.IsNotNull (provider, "provider was not created.");
  634. Assert.AreEqual (16, provider.Count);
  635. }
  636. [Ignore("TODO")]
  637. [Test()]
  638. public void TestMethodTypeParameter ()
  639. {
  640. IParameterDataProvider provider = CreateProvider (
  641. @"using System;
  642. namespace Test
  643. {
  644. class A
  645. {
  646. void TestMethod<T, S>()
  647. {
  648. }
  649. void Method ()
  650. {
  651. $TestMethod<$
  652. }
  653. }
  654. }");
  655. Assert.IsNotNull (provider, "provider was not created.");
  656. Assert.AreEqual (1, provider.Count);
  657. }
  658. [Ignore("TODO")]
  659. [Test()]
  660. public void TestSecondMethodTypeParameter ()
  661. {
  662. IParameterDataProvider provider = CreateProvider (
  663. @"using System;
  664. namespace Test
  665. {
  666. class A
  667. {
  668. void TestMethod<T, S>()
  669. {
  670. }
  671. void Method ()
  672. {
  673. $TestMethod<string,$
  674. }
  675. }
  676. }");
  677. Assert.IsNotNull (provider, "provider was not created.");
  678. Assert.AreEqual (1, provider.Count);
  679. }
  680. [Test()]
  681. public void TestArrayParameter ()
  682. {
  683. var provider = CreateProvider (
  684. @"
  685. class TestClass
  686. {
  687. public void Method()
  688. {
  689. int[,,,] arr;
  690. $arr[$
  691. }
  692. }");
  693. Assert.IsNotNull (provider, "provider was not created.");
  694. Assert.AreEqual (1, provider.Count);
  695. }
  696. [Test()]
  697. public void TestSecondArrayParameter ()
  698. {
  699. var provider = CreateProvider (
  700. @"
  701. class TestClass
  702. {
  703. public void Method()
  704. {
  705. int[,,,] arr;
  706. $arr[5,$
  707. }
  708. }");
  709. Assert.IsNotNull (provider, "provider was not created.");
  710. Assert.AreEqual (1, provider.Count);
  711. }
  712. [Ignore("TODO!")]
  713. [Test()]
  714. public void TestTypeParameterInBaseType ()
  715. {
  716. IParameterDataProvider provider = CreateProvider (
  717. @"using System;
  718. namespace Test
  719. {
  720. $class A : Tuple<$
  721. }");
  722. Assert.IsNotNull (provider, "provider was not created.");
  723. Assert.AreEqual (16, provider.Count);
  724. }
  725. [Test()]
  726. public void TestBaseConstructorCall ()
  727. {
  728. IParameterDataProvider provider = CreateProvider (
  729. @"class Base
  730. {
  731. public Base (int i)
  732. {
  733. }
  734. public Base (int i, string s)
  735. {
  736. }
  737. }
  738. namespace Test
  739. {
  740. class A : Base
  741. {
  742. $public A () : base($
  743. }
  744. }");
  745. Assert.IsNotNull (provider, "provider was not created.");
  746. Assert.AreEqual (2, provider.Count);
  747. }
  748. [Test()]
  749. public void TestThisConstructorCall ()
  750. {
  751. IParameterDataProvider provider = CreateProvider (
  752. @"class Base
  753. {
  754. public Base (int i)
  755. {
  756. }
  757. public Base (int i, string s)
  758. {
  759. }
  760. }
  761. namespace Test
  762. {
  763. class A : Base
  764. {
  765. public A (int a, int b) : base(a) {}
  766. $public A () : this($
  767. }
  768. }");
  769. Assert.IsNotNull (provider, "provider was not created.");
  770. Assert.AreEqual (1, provider.Count);
  771. }
  772. /// <summary>
  773. /// Bug 3645 - [New Resolver]Parameter completion shows all static and non-static overloads
  774. /// </summary>
  775. [Test()]
  776. public void TestBug3645 ()
  777. {
  778. IParameterDataProvider provider = CreateProvider (
  779. @"class Main
  780. {
  781. public static void FooBar (string str)
  782. {
  783. }
  784. public void FooBar (int i)
  785. {
  786. }
  787. public static void Main (string[] args)
  788. {
  789. $FooBar ($
  790. }
  791. }");
  792. Assert.IsNotNull (provider, "provider was not created.");
  793. Assert.AreEqual (1, provider.Count);
  794. }
  795. /// <summary>
  796. /// Bug 3991 - constructor argument completion not working for attributes applied to methods or parameters
  797. /// </summary>
  798. [Test()]
  799. public void TestBug3991()
  800. {
  801. IParameterDataProvider provider = CreateProvider(
  802. @"using System;
  803. namespace Test
  804. {
  805. class TestClass
  806. {
  807. [Obsolete$($]
  808. TestClass()
  809. {
  810. }
  811. }
  812. }
  813. ");
  814. Assert.IsNotNull(provider, "provider was not created.");
  815. Assert.Greater(provider.Count, 0);
  816. }
  817. /// <summary>
  818. /// Bug 4087 - code completion handles object and collection initializers (braces) incorrectly in method calls
  819. /// </summary>
  820. [Test()]
  821. public void TestBug4087()
  822. {
  823. IParameterDataProvider provider = CreateProvider(
  824. @"using System;
  825. class TestClass
  826. {
  827. TestClass()
  828. {
  829. $Console.WriteLine (new int[]{ 4, 5,$
  830. }
  831. }
  832. ");
  833. Assert.IsTrue (provider == null || provider.Count == 0);
  834. }
  835. /// <summary>
  836. /// Bug 4927 - [New Resolver] Autocomplete shows non-static methods when using class name
  837. /// </summary>
  838. [Test()]
  839. public void TestBug4927 ()
  840. {
  841. IParameterDataProvider provider = CreateProvider (
  842. @"
  843. public class A
  844. {
  845. // static method
  846. public static void Method(string someParameter, object anotherParameter)
  847. {
  848. }
  849. // instance method
  850. public void Method()
  851. {
  852. }
  853. }
  854. public class B
  855. {
  856. public static void Main()
  857. {
  858. $A.Method($
  859. }
  860. }
  861. ");
  862. Assert.IsNotNull (provider, "provider was not created.");
  863. Assert.AreEqual (1, provider.Count);
  864. }
  865. }
  866. }