public void EmptyXmlDocumentTokenization()
 {
     var s = new TextSource("");
     var t = CreateTokenizer(s);
     var e = t.Get();
     Assert.IsInstanceOf<XmlEndOfFileToken>(e);
 }

		public void PaintParaBox()
		{
			AssembledStyles styles = new AssembledStyles();
			var clientRuns = new List<IClientRun>();
			BlockBox box0 = new BlockBox(styles, Color.Red, 72000, 36000);
			clientRuns.Add(box0);
			BlockBox box1 = new BlockBox(styles, Color.Blue, 36000, 18000);
			clientRuns.Add(box1);
			BlockBox box2 = new BlockBox(styles, Color.Red, 24000, 18000);
			clientRuns.Add(box2);
			BlockBox box3 = new BlockBox(styles, Color.Red, 72000, 36000);
			clientRuns.Add(box3);
			BlockBox box4 = new BlockBox(styles, Color.Red, 36000, 36000);
			clientRuns.Add(box4);

			TextSource source = new TextSource(clientRuns, null);
			ParaBox para = new ParaBox(styles, source);
			RootBox root = new RootBox(styles);
			root.AddBox(para);

			MockGraphics graphics = new MockGraphics();
			LayoutInfo layoutArgs = ParaBuilderTests.MakeLayoutInfo(100, graphics);
			root.Layout(layoutArgs);

			PaintTransform ptrans = new PaintTransform(2, 2, 96, 96, 0, 0, 96, 96);
			root.Paint(graphics, ptrans);
			Assert.AreEqual(5, graphics.RectanglesDrawn.Count);
			VerifyRect(2, 2, 96, 48, graphics, 0, Color.Red);
			VerifyRect(2, 48+2, 48, 24, graphics, 1, Color.Blue);
			VerifyRect(2+48, 48 + 2, 32, 24, graphics, 2, Color.Red);
			VerifyRect(2, 24 + 48 + 2, 96, 48, graphics, 3, Color.Red);
			VerifyRect(2, 48 + 24 + 48 + 2, 48, 48, graphics, 4, Color.Red);
		}

 public void TokenizationTagSelfClosingDetected()
 {
     var s = new TextSource("<img />");
     var t = new HtmlTokenizer(s, null);
     var token = t.Get();
     Assert.AreEqual(true, ((HtmlTagToken)token).IsSelfClosing);
 }

 public override INode Clone(Boolean deep = true)
 {
     var source = new TextSource(Source.Text);
     var node = new HtmlDocument(Context, source);
     CloneDocument(node, deep);
     return node;
 }

 public void TokenizationTagNameDetection()
 {
     var s = new TextSource("<span>");
     var t = new HtmlTokenizer(s, null);
     var token = t.Get();
     Assert.AreEqual("span", ((HtmlTagToken)token).Name);
 }

 public void TokenizationFinalEOF()
 {
     var s = new TextSource("");
     var t = new HtmlTokenizer(s, null);
     var token = t.Get();
     Assert.AreEqual(HtmlTokenType.EndOfFile, token.Type);
 }

        internal static void ClearSelected(TextSource ts)
        {
            var tb = ts.CurrentTB;

            Place start = tb.Selection.Start;
            Place end = tb.Selection.End;
            int fromLine = Math.Min(end.iLine, start.iLine);
            int toLine = Math.Max(end.iLine, start.iLine);
            int fromChar = tb.Selection.FromX;
            int toChar = tb.Selection.ToX;
            if (fromLine < 0) return;
            //
            if (fromLine == toLine)
                ts[fromLine].RemoveRange(fromChar, toChar - fromChar);
            else
            {
                ts[fromLine].RemoveRange(fromChar, ts[fromLine].Count - fromChar);
                ts[toLine].RemoveRange(0, toChar);
                ts.RemoveLine(fromLine + 1, toLine - fromLine - 1);
                InsertCharCommand.MergeLines(fromLine, ts);
            }
            //
            tb.Selection.Start = new Place(fromChar, fromLine);
            //
            ts.NeedRecalc(new TextSource.TextChangedEventArgs(fromLine, toLine));
        }

 /// <summary>
 /// See 8.2.4 Tokenization
 /// </summary>
 /// <param name="source">The source code manager.</param>
 /// <param name="events">The event aggregator to use.</param>
 public HtmlTokenizer(TextSource source, IEventAggregator events)
     : base(source, events)
 {
     _state = HtmlParseMode.PCData;
     _acceptsCharacterData = false;
     _lastStartTag = String.Empty;
 }

 public void TokenizationBogusCommentQuestionMark()
 {
     var s = new TextSource("<?>");
     var t = new HtmlTokenizer(s, null);
     var token = t.Get();
     Assert.AreEqual(HtmlTokenType.Comment, token.Type);
     Assert.AreEqual("?", token.Data);
 }

 public void TokenizationBogusCommentClosingTag()
 {
     var s = new TextSource("</ >");
     var t = new HtmlTokenizer(s, null);
     var token = t.Get();
     Assert.AreEqual(HtmlTokenType.Comment, token.Type);
     Assert.AreEqual(" ", token.Data);
 }

 public void TokenizationBogusCommentEmpty()
 {
     var s = new TextSource("<!>");
     var t = new HtmlTokenizer(s, null);
     var token = t.Get();
     Assert.AreEqual(HtmlTokenType.Comment, token.Type);
     Assert.AreEqual(String.Empty, token.Data);
 }

 public void TokenizationStartTagDetection()
 {
     var s = new TextSource("<p>");
     var t = new HtmlTokenizer(s, null);
     var token = t.Get();
     Assert.AreEqual(HtmlTokenType.StartTag, token.Type);
     Assert.AreEqual("p", ((HtmlTagToken)token).Name);
 }

 /// <summary>
 /// Sets a new default stylesheet defined by the provided string.
 /// </summary>
 /// <param name="sourceCode">The source for a new base stylesheet.</param>
 /// <returns>The CSSOM of the parsed source.</returns>
 public ICssStyleSheet SetDefault(String sourceCode)
 {
     var parser = new CssParser(_options);
     var source = new TextSource(sourceCode);
     var sheet = new CssStyleSheet(parser, default(String), default(ICssStyleSheet));
     _default = Parse(parser, sheet, source).Result;
     return _default;
 }

 public void ValidXmlDeclarationOnlyVersion()
 {
     var s = new TextSource("<?xml version=\"1.0\"?>");
     var t = CreateTokenizer(s);
     var e = t.Get();
     Assert.AreEqual(XmlTokenType.Declaration, e.Type);
     Assert.AreEqual("1.0", ((XmlDeclarationToken)e).Version);
 }

        public Reader(TextSource textSource, TextRenderer textRenderer, double maxWPM)
        {
            this.maxWPM = maxWPM;
            this.textRenderer = textRenderer;
            this.textSource = textSource;

            this.wordTimer = new Timer(START_WORD_INTERVAL);
            wordTimer.Elapsed += new ElapsedEventHandler(wordTimerHandler);
        }

 public void TokenizationLongerCharacterReference()
 {
     var content = "&abcdefghijklmnopqrstvwxyzABCDEFGHIJKLMNOPQRSTV;";
     var s = new TextSource(content);
     var t = new HtmlTokenizer(s, null);
     var token = t.Get();
     Assert.AreEqual(HtmlTokenType.Character, token.Type);
     Assert.AreEqual(content, token.Data);
 }

 /// <summary>
 /// See 8.2.4 Tokenization
 /// </summary>
 /// <param name="source">The source code manager.</param>
 /// <param name="resolver">The entity resolver to use.</param>
 public HtmlTokenizer(TextSource source, IEntityProvider resolver)
     : base(source)
 {
     State = HtmlParseMode.PCData;
     IsAcceptingCharacterData = false;
     IsStrictMode = false;
     _lastStartTag = String.Empty;
     _resolver = resolver;
 }

		public void StringsInSource()
		{
			ITsString tss = tsf.MakeString("abc def", wsEn);
			AssembledStyles styles = new AssembledStyles();
			TssClientRun clientRun = new TssClientRun(tss, styles);
			var clientRuns = new List<IClientRun>();
			clientRuns.Add(clientRun);
			TextSource ts = new TextSource(clientRuns);
		}

 public void OneCommentInXmlDocument()
 {
     var c = "My comment";
     var s = new TextSource("<!--" + c + "-->");
     var t = CreateTokenizer(s);
     var e = t.Get();
     Assert.AreEqual(XmlTokenType.Comment, e.Type);
     Assert.AreEqual(c, ((XmlCommentToken)e).Data);
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="ts">Underlaying TextSource</param>
 /// <param name="iLines">List of line indices to be removed</param>
 public RemoveLinesCommand(TextSource ts, List<int> iLines)
     : base(ts)
 {
     //sort iLines
     iLines.Sort();
     //
     this.iLines = iLines;
     lastSel = sel = new RangeInfo(ts.CurrentTB.Selection);
 }