C# Scope.DefineInnerScope方法代码示例

 public void DefineInnerScope_InCombinedParentOfTwoInners_SetsRootScopeOnInner()
 {
     Scope root = new     Scope("0123456789");
     Scope parent = root.DefineInnerScope(5, 4);
     //5678
     Scope combinedParent = root.DefineInnerScope(5, 5);//5678+9
     Scope innerChild = root.DefineInnerScope(6, 2);//67
     Assert.AreEqual(combinedParent.InnerLeftScope, innerChild.ParentScope);
     Assert.AreEqual(combinedParent, combinedParent.InnerLeftScope.ParentScope);
     Assert.AreEqual(combinedParent, combinedParent.InnerRightScope.ParentScope);
 }

        public void DefineInnerScope_WithleftMiddleandRightScopesasInner()
        {
            Scope root = new Scope("012345");
            root.DefineInnerScope(3, 1);//012|3|45
            ScopeSplitter splitter = new ScopeSplitter();
            splitter.AutoSplit(root, 2, 3, true);//01|(2|3|4)|5

            Scope encapsulator = root.DefineInnerScope(2, 3);
            Assert.AreEqual("2", encapsulator.InnerLeftScope.Text);
            Assert.AreEqual("3", encapsulator.InnerMiddleScope.Text);
            Assert.AreEqual("4", encapsulator.InnerRightScope.Text);
        }

 public void SetInnerScope_EncapsulatingInnerScopes_CreatesOuterScopeWithInnerScopes()
 {
     Scope root = new Scope("abcd");
     root.DefineInnerScope(1, 1);//b
     root.DefineInnerScope(2, 1);//'c' as inner of 'cd'
     Scope encapsulating = root.DefineInnerScope(1, 2);//'b'+'c' splitting 'd' to an implicit scope
     Assert.AreEqual("bc", encapsulating.Text);
 }

 public void SetInnerScope_WithScopeInTheEnd_DoesntSetInnerMiddleScope()
 {
     scope = new Scope("abc");
     Scope newone = scope.DefineInnerScope(2, 1);
     Assert.IsNull(scope.InnerMiddleScope);
 }

 public void SetInnerScope_SetsParentCorrectlyRightScope()
 {
     Scope rootScope = new Scope("abc");
     rootScope.DefineInnerScope(1, 1);
     Assert.AreSame(rootScope, rootScope.InnerRightScope.ParentScope);
 }

 public void SetInnerScope_SetsInnerRightScopePropertyToRightScope2()
 {
     scope = new Scope("defge");
     scope.DefineInnerScope(2, 1);
     Scope rightScopeWithCorrectProperties = new Scope("ge", 3);
     rightScopeWithCorrectProperties.IsExplicit = false;
     Assert.IsTrue(rightScopeWithCorrectProperties.Equals(scope.InnerRightScope));
 }

        public void DefineInnerScope_WithleftMiddleandRightScopesasInner_RemovesOriginalScopesFromDirectRootAndIntoNewScope()
        {
            Scope root = new Scope("012");
            root.DefineInnerScope(1, 1);//1
            root.InnerRightScope.Suggestions.Add(new Suggestion("a","b"));
            root.InnerMiddleScope.Suggestions.Add(new Suggestion("a","b"));

            Scope encapsulator = root.DefineInnerScope(0, 2);//01

            Assert.AreEqual("0", encapsulator.InnerLeftScope.Text);
            Assert.AreEqual(null, encapsulator.InnerMiddleScope);
            Assert.AreEqual("1", encapsulator.InnerRightScope.Text);

            Assert.AreEqual("2", root.InnerRightScope.Text);
            Assert.AreEqual("01", root.InnerLeftScope.Text);
            Assert.AreEqual(null, root.InnerMiddleScope);

            Assert.AreEqual(1, root.InnerRightScope.Suggestions.Count);
            Assert.AreEqual(1, encapsulator.InnerRightScope.Suggestions.Count);
            Assert.AreEqual(encapsulator, encapsulator.InnerRightScope.ParentScope);
            Assert.AreEqual(encapsulator, encapsulator.InnerLeftScope.ParentScope);
        }

 public void SetInnerScope_SetsInnerLeftScopePropertyToLeftScope2()
 {
     scope = new Scope("defg");
     scope.DefineInnerScope(2, 1);
     Scope leftScopeWithCorrectProperties = new Scope("de", 0);
     leftScopeWithCorrectProperties.IsExplicit = false;
     Assert.IsTrue(leftScopeWithCorrectProperties.Equals(scope.InnerLeftScope));
 }

 public void SetInnerScope_SameScopeAsParent_ThrowsExcpetion()
 {
     scope = new Scope("abc");
     Scope inner = scope.DefineInnerScope(0, 3);
 }

 public void SetInnerScope_OnFirstCharInInnerScope_InnerInnerLeftScopeTextIsOK()
 {
     scope = new Scope("a text b");
     scope.DefineInnerScope(1, 5);//' text'
     scope.DefineInnerScope(1, 1);//' ' inside inner middle scope
     Assert.AreEqual(" ", scope.InnerMiddleScope.InnerLeftScope.Text);
 }

 public void SetInnerScope_IsFlat_CreatesTwoExtraScopesIfScopeIsInTheMiddle2()
 {
     scope = new Scope("abcd");
     Scope inner = scope.DefineInnerScope(1, 2);
     Scope[] innerScopes = scope.GetInnerScopes();
     Assert.AreEqual(3, innerScopes.Length);
 }

 public void SetInnerScope_IsFlat_CreatesOneExtraScopesIfScopeIsInTheEnd()
 {
     scope = new Scope("abc");
     Scope inner = scope.DefineInnerScope(2, 1);
     Scope[] innerScopes = scope.GetInnerScopes();
     Assert.AreEqual(2, innerScopes.Length);
 }

 public void SetInnerScope_IfInnerScopeExists_DoesNotThrowsException()
 {
     scope = new Scope("abc");
     scope.DefineInnerScope(0, 1);
     scope.DefineInnerScope(2, 1);
 }

        public void SetInnerScope_EncapsulatingInnerScopes_CreatesRightImplicitScopeSplitted()
        {
            Scope root = new Scope("abcd");
            root.DefineInnerScope(1, 1);//b
            Assert.AreEqual("cd", root.InnerRightScope.Text);

            Scope encapsulating = root.DefineInnerScope(1, 2);//'b'+'c' splitting 'd' to an implicit scope

            Assert.AreEqual("d", root.InnerRightScope.Text);
            Assert.AreEqual("bc", root.InnerMiddleScope.Text);
            Assert.AreEqual(true, root.InnerRightScope.IsImplicit);
            Assert.AreEqual("b", encapsulating.InnerLeftScope.Text);
            Assert.AreEqual("c", encapsulating.InnerRightScope.Text);
        }

 public void SetInnerScope_EncapsulatingInnerScopes_CreatesOuterScopeWithInnerScopes2()
 {
     Scope root = new Scope("abcd");
     root.DefineInnerScope(1, 1);//b
     root.DefineInnerScope(2, 1);//'c' as inner of 'cd'
     Scope encapsulating = root.DefineInnerScope(1, 3);//'bcd'
     Assert.AreEqual("bcd", encapsulating.Text);
 }