public void GetStartPoint_VariableStartsAtColumn5_ReturnsTextPointWithLineCharOffset5()
        {
            CreatePublicVariable("MyVariable");
            VariableStartsAtColumn(5);

            TextPoint point  = codeVariable.GetStartPoint();
            int       offset = point.LineCharOffset;

            Assert.AreEqual(5, offset);
        }
        void CreateFieldEditPoint()
        {
            var startPoint = (TextPoint)codeVariable.GetStartPoint();

            endPoint  = (TextPoint)codeVariable.GetEndPoint();
            editPoint = (EditPoint)startPoint.CreateEditPoint();
        }
示例#3
0
        void CreateFieldEditPoint()
        {
            var       codeVariable = new CodeVariable(fieldHelper.Field, documentLoader);
            TextPoint startPoint   = codeVariable.GetStartPoint();

            endPoint  = codeVariable.GetEndPoint();
            editPoint = startPoint.CreateEditPoint();
        }
        public async Task GetStartPoint_WholeWithAttributes()
        {
            CodeVariable testObject = await GetCodeVariableAsync("A", "intC");

            TextPoint startPoint = testObject.GetStartPoint(vsCMPart.vsCMPartWholeWithAttributes);

            Assert.Equal(13, startPoint.Line);
            Assert.Equal(5, startPoint.LineCharOffset);
        }
        public async Task GetStartPoint_Navigate()
        {
            CodeVariable testObject = await GetCodeVariableAsync("A", "intC");

            TextPoint startPoint = testObject.GetStartPoint(vsCMPart.vsCMPartNavigate);

            Assert.Equal(14, startPoint.Line);
            Assert.Equal(17, startPoint.LineCharOffset);
        }
        public void GetStartPoint_AttributesWithDelimiter()
        {
            CodeVariable testObject = GetCodeVariable("A", "intC");

            TextPoint startPoint = testObject.GetStartPoint(vsCMPart.vsCMPartAttributesWithDelimiter);

            Assert.Equal(13, startPoint.Line);
            Assert.Equal(5, startPoint.LineCharOffset);
        }
        public void GetStartPoint_Navigate()
        {
            CodeVariable testObject = GetCodeVariable("A", "intC");

            TextPoint startPoint = testObject.GetStartPoint(vsCMPart.vsCMPartNavigate);

            Assert.Equal(14, startPoint.Line);
            Assert.Equal(17, startPoint.LineCharOffset);
        }
        public string ExtractMember(CodeVariable variable)
        {
            var memberStart = variable.GetStartPoint().CreateEditPoint();
            var memberText  = string.Empty;

            memberText += memberStart.GetText(variable.GetEndPoint());
            memberStart.Delete(variable.GetEndPoint());
            return(memberText);
        }
        public void GetStartPoint_VariableStartsAtColumnOneOnLineTwo_ReturnsTextPointWithLineCharOffsetOneAndLineTwo()
        {
            CreateCodeVariable(
                "public class Foo {\r\n" +
                "int V;\r\n" +
                "}");

            global::EnvDTE.TextPoint point = codeVariable.GetStartPoint();

            Assert.AreEqual(1, point.LineCharOffset);
            Assert.AreEqual(2, point.Line);
        }
        public void AddPublicVariable_VariableTypeIsString_ReturnsCodeVariable()
        {
            CreateClass("MyClass");
            CreateCodeGenerator();
            string fileName = @"d:\projects\myproject\MyClass.cs";

            SetClassFileName(fileName);
            SetDocumentFileName(fileName);
            AddFieldToClassForReparse("MyClass.MyVariable", new DomRegion(1, 2, 1, 5));

            AddPublicVariable("MyVariable", "System.String");

            TextPoint start = codeVariable.GetStartPoint();
            TextPoint end   = codeVariable.GetEndPoint();

            Assert.AreEqual("MyVariable", codeVariable.Name);
            Assert.AreEqual(1, start.Line);
            Assert.AreEqual(2, start.LineCharOffset);
            Assert.AreEqual(1, end.Line);
            Assert.AreEqual(5, end.LineCharOffset);
        }
        public void GetStartPoint_Whole()
        {
            CodeVariable testObject = GetCodeVariable("A", "intC");

            AssertEx.Throws <NotImplementedException>(() => testObject.GetStartPoint(vsCMPart.vsCMPartWhole));
        }
        public async Task GetStartPoint_Whole()
        {
            CodeVariable testObject = await GetCodeVariableAsync("A", "intC");

            Assert.Throws <NotImplementedException>(() => testObject.GetStartPoint(vsCMPart.vsCMPartWhole));
        }
        public async Task GetStartPoint_HeaderWithAttributes()
        {
            CodeVariable testObject = await GetCodeVariableAsync("A", "intC");

            Assert.Throws <NotImplementedException>(() => testObject.GetStartPoint(vsCMPart.vsCMPartHeaderWithAttributes));
        }
        public async Task GetStartPoint_BodyWithDelimiter()
        {
            CodeVariable testObject = await GetCodeVariableAsync("A", "intC");

            Assert.Throws <NotImplementedException>(() => testObject.GetStartPoint(vsCMPart.vsCMPartBodyWithDelimiter));
        }
        public async Task GetStartPoint_Body()
        {
            CodeVariable testObject = await GetCodeVariableAsync("A", "intC");

            Assert.Throws <COMException>(() => testObject.GetStartPoint(vsCMPart.vsCMPartBody));
        }
        public void GetStartPoint_HeaderWithAttributes()
        {
            CodeVariable testObject = GetCodeVariable("A", "intC");

            AssertEx.Throws <NotImplementedException>(() => testObject.GetStartPoint(vsCMPart.vsCMPartHeaderWithAttributes));
        }
        public void GetStartPoint_BodyWithDelimiter()
        {
            CodeVariable testObject = GetCodeVariable("A", "intC");

            AssertEx.Throws <NotImplementedException>(() => testObject.GetStartPoint(vsCMPart.vsCMPartBodyWithDelimiter));
        }
        public void GetStartPoint_Body()
        {
            CodeVariable testObject = GetCodeVariable("A", "intC");

            AssertEx.Throws <COMException>(() => testObject.GetStartPoint(vsCMPart.vsCMPartBody));
        }