public void GetCharIndexFromLineColumnIndex() { TextBuffer text; SplitArray <int> lhi; SplitArray <LineDirtyState> lds; MakeTestData(out text, out lhi, out lds); Assert.AreEqual(0, TextUtil.GetCharIndexFromLineColumnIndex(text, lhi, 0, 0)); Assert.AreEqual(34, TextUtil.GetCharIndexFromLineColumnIndex(text, lhi, 2, 1)); Assert.AreEqual(71, TextUtil.GetCharIndexFromLineColumnIndex(text, lhi, 6, 18)); MyAssert.Throws <AssertException>(delegate { TextUtil.GetCharIndexFromLineColumnIndex(text, lhi, 6, 19); }); MyAssert.Throws <AssertException>(delegate { TextUtil.GetCharIndexFromLineColumnIndex(text, lhi, 0, 100); }); }
public void NextLineHead() { TextBuffer text = new TextBuffer(1, 32); text.Insert(0, TestData.ToCharArray()); MyAssert.Throws <AssertException>(delegate { TextUtil.NextLineHead(text, -1); }); int i = 0; for ( ; i < 32; i++) { Assert.AreEqual(32, TextUtil.NextLineHead(text, i)); } for ( ; i < 33; i++) { Assert.AreEqual(33, TextUtil.NextLineHead(text, i)); } for ( ; i < 37; i++) { Assert.AreEqual(37, TextUtil.NextLineHead(text, i)); } for ( ; i < 38; i++) { Assert.AreEqual(38, TextUtil.NextLineHead(text, i)); } for ( ; i < 52; i++) { Assert.AreEqual(52, TextUtil.NextLineHead(text, i)); } for ( ; i < 53; i++) { Assert.AreEqual(53, TextUtil.NextLineHead(text, i)); } for ( ; i < 71; i++) { Assert.AreEqual(-1, TextUtil.NextLineHead(text, i)); } Assert.AreEqual(-1, TextUtil.NextLineHead(text, i)); }
public void LineHeadIndexFromCharIndex() { TextBuffer text; SplitArray <int> lhi; MakeTestData(out text, out lhi); int i = 0; for ( ; i < 32; i++) { Assert.AreEqual(0, TextUtil.GetLineHeadIndexFromCharIndex(text, lhi, i)); } for ( ; i < 33; i++) { Assert.AreEqual(32, TextUtil.GetLineHeadIndexFromCharIndex(text, lhi, i)); } for ( ; i < 37; i++) { Assert.AreEqual(33, TextUtil.GetLineHeadIndexFromCharIndex(text, lhi, i)); } for ( ; i < 38; i++) { Assert.AreEqual(37, TextUtil.GetLineHeadIndexFromCharIndex(text, lhi, i)); } for ( ; i < 52; i++) { Assert.AreEqual(38, TextUtil.GetLineHeadIndexFromCharIndex(text, lhi, i)); } for ( ; i < 53; i++) { Assert.AreEqual(52, TextUtil.GetLineHeadIndexFromCharIndex(text, lhi, i)); } for ( ; i <= 71; i++) { Assert.AreEqual(53, TextUtil.GetLineHeadIndexFromCharIndex(text, lhi, i)); } MyAssert.Throws <AssertException>(delegate { TextUtil.GetLineHeadIndexFromCharIndex(text, lhi, i); }); }
public void GetLineColumnIndexFromCharIndex() { // keep it as simple as possible\r\n // but\n // not simpler.\r\n Document doc = new Document(); int line, column; int i = 0; doc.Text = "keep it as simple as possible\r\nbut\nnot simpler.\r\n"; i = 0; for ( ; i < 31; i++) { doc.GetLineColumnIndexFromCharIndex(i, out line, out column); Assert.AreEqual(0, line); Assert.AreEqual(i, column); } for ( ; i < 35; i++) { doc.GetLineColumnIndexFromCharIndex(i, out line, out column); Assert.AreEqual(1, line); Assert.AreEqual(i - 31, column); } for ( ; i < 49; i++) { doc.GetLineColumnIndexFromCharIndex(i, out line, out column); Assert.AreEqual(2, line); Assert.AreEqual(i - 35, column); } doc.GetLineColumnIndexFromCharIndex(49, out line, out column); Assert.AreEqual(3, line); Assert.AreEqual(i - 49, column); // out of range MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetLineColumnIndexFromCharIndex(50, out line, out column); }); }
public void GetLineColumnIndexFromCharIndex() { TextBuffer text; SplitArray <int> lhi; int l, c; MakeTestData(out text, out lhi); TextUtil.GetLineColumnIndexFromCharIndex(text, lhi, 0, out l, out c); Assert.AreEqual(0, l); Assert.AreEqual(0, c); TextUtil.GetLineColumnIndexFromCharIndex(text, lhi, 2, out l, out c); Assert.AreEqual(0, l); Assert.AreEqual(2, c); TextUtil.GetLineColumnIndexFromCharIndex(text, lhi, 40, out l, out c); Assert.AreEqual(4, l); Assert.AreEqual(2, c); TextUtil.GetLineColumnIndexFromCharIndex(text, lhi, 71, out l, out c); // 71 --> EOF Assert.AreEqual(6, l); Assert.AreEqual(18, c); MyAssert.Throws <AssertException>(delegate { TextUtil.GetLineColumnIndexFromCharIndex(text, lhi, 72, out l, out c); }); }
public void GetLineLength() { // 0 keep it\r // 1 \r // 2 as simple as possible\r\n // 3 \n // 4 but\n // 5 \r\n // 6 not simpler. Document doc = new Document(); doc.Text = "keep it\r\ras simple as possible\r\n\nbut\n\r\nnot simpler."; Assert.AreEqual(7, doc.GetLineLength(0)); Assert.AreEqual(0, doc.GetLineLength(1)); Assert.AreEqual(21, doc.GetLineLength(2)); Assert.AreEqual(0, doc.GetLineLength(3)); Assert.AreEqual(3, doc.GetLineLength(4)); Assert.AreEqual(0, doc.GetLineLength(5)); Assert.AreEqual(12, doc.GetLineLength(6)); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetLineLength(7); }); }
public void LHI_Delete() { // TEST DATA: // -------------------- // "keep it as simple as possible\r\n (head: 0, len:31) // \n (head:32, len: 1) // but\n (head:33, len: 4) // \r (head:37, len: 1) // not simpler."\r (head:38, len:14) // \r (head:52, len: 1) // - Albert Einstein (head:53, len:18) // -------------------- const string TestData = "\"keep it as simple as possible\r\n\nbut\n\rnot simpler.\"\r\r - Albert Einstein"; TextBuffer text = new TextBuffer(1, 32); SplitArray <int> lhi = new SplitArray <int>(1, 8); SplitArray <LineDirtyState> lds = new SplitArray <LineDirtyState>(1, 8); lds.Add(LineDirtyState.Clean); // prepare lhi.Add(0); TextUtil.LHI_Insert(lhi, lds, text, TestData, 0); text.Add(TestData.ToCharArray()); Assert.AreEqual("0 32 33 37 38 52 53", lhi.ToString()); Assert.AreEqual("DDDDDDD", MakeLdsText(lds)); for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } //--- delete range in line --- // valid range TextUtil.LHI_Delete(lhi, lds, text, 2, 5); text.RemoveRange(2, 5); Assert.AreEqual("0 29 30 34 35 49 50", lhi.ToString()); Assert.AreEqual("DCCCCCC", MakeLdsText(lds)); // invalid range (before begin to middle) MyAssert.Throws <AssertException>(delegate { TextUtil.LHI_Delete(lhi, lds, text, -1, 5); }); //--- delete range between different lines --- text.Clear(); lhi.Clear(); lhi.Add(0); lds.Clear(); lds.Add(LineDirtyState.Clean); TextUtil.LHI_Insert(lhi, lds, text, TestData, 0); text.Add(TestData.ToCharArray()); // "keep it as simple as possible\r\n (head: 0, len:31) // \n (head:32, len: 1) // but\n (head:33, len: 4) // \r (head:37, len: 1) // not simpler."\r (head:38, len:14) // \r (head:52, len: 1) // - Albert Einstein[EOF] (head:53, len:18) // delete only one EOL code //---- // "keep it as simple as possible\r\n (head: 0, len:31) // but\n (head:32, len: 4) // \r (head:36, len: 1) // not simpler."\r (head:37, len:14) // \r (head:51, len: 1) // - Albert Einstein[EOF] (head:52, len:18) //---- for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } TextUtil.LHI_Delete(lhi, lds, text, 32, 33); text.RemoveAt(32); Assert.AreEqual("0 32 36 37 51 52", lhi.ToString()); Assert.AreEqual("CDCCCC", MakeLdsText(lds)); // delete middle of the first line to not EOF pos //---- // "keep it as simple as not simpler."\r (head: 0, len:35) // \r (head:36, len: 1) // - Albert Einstein[EOF] (head:37, len:18) //---- for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } TextUtil.LHI_Delete(lhi, lds, text, 22, 37); text.RemoveRange(22, 37); Assert.AreEqual("0 36 37", lhi.ToString()); Assert.AreEqual("DCC", MakeLdsText(lds)); // delete all //---- // [EOF] (head:0, len:0) //---- for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } TextUtil.LHI_Delete(lhi, lds, text, 0, 55); text.RemoveRange(0, 55); Assert.AreEqual("0", lhi.ToString()); Assert.AreEqual("D", MakeLdsText(lds)); //--- special care about CR+LF --- // (1) deletion creates a new CR+LF // (2) deletion breaks a CR+LF at the left side of the deletion range // (3) deletion breaks a CR+LF at the left side of the deletion range //-------------------------------- // (1) { text.Clear(); lhi.Clear(); lhi.Add(0); lds.Clear(); lds.Add(LineDirtyState.Clean); TextUtil.LHI_Insert(lhi, lds, text, "foo\rx\nbar", 0); text.Add("foo\rx\nbar".ToCharArray()); for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } TextUtil.LHI_Delete(lhi, lds, text, 4, 5); text.RemoveRange(4, 5); Assert.AreEqual("0 5", lhi.ToString()); Assert.AreEqual("DC", MakeLdsText(lds)); } // (2) { text.Clear(); lhi.Clear(); lhi.Add(0); lds.Clear(); lds.Add(LineDirtyState.Clean); TextUtil.LHI_Insert(lhi, lds, text, "foo\r\nbar", 0); text.Add("foo\r\nbar".ToCharArray()); for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } TextUtil.LHI_Delete(lhi, lds, text, 4, 6); text.RemoveRange(4, 6); Assert.AreEqual("0 4", lhi.ToString()); Assert.AreEqual("DD", MakeLdsText(lds)); } // (3) { text.Clear(); lhi.Clear(); lhi.Add(0); lds.Clear(); lds.Add(LineDirtyState.Clean); TextUtil.LHI_Insert(lhi, lds, text, "foo\r\nbar", 0); text.Add("foo\r\nbar".ToCharArray()); for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } TextUtil.LHI_Delete(lhi, lds, text, 2, 4); text.RemoveRange(2, 4); Assert.AreEqual("0 3", lhi.ToString()); Assert.AreEqual("DC", MakeLdsText(lds)); } // (1)+(2)+(3) { text.Clear(); lhi.Clear(); lhi.Add(0); lds.Clear(); lds.Add(LineDirtyState.Clean); TextUtil.LHI_Insert(lhi, lds, text, "\r\nfoo\r\n", 0); text.Add("\r\nfoo\r\n".ToCharArray()); for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } TextUtil.LHI_Delete(lhi, lds, text, 1, 6); text.RemoveRange(1, 6); Assert.AreEqual("0 2", lhi.ToString()); Assert.AreEqual("DC", MakeLdsText(lds)); } //--- misc --- // insert "\n" after '\r' at end of document (boundary check for LHI_Insert) { text.Clear(); lhi.Clear(); lhi.Add(0); lds.Clear(); lds.Add(LineDirtyState.Clean); TextUtil.LHI_Insert(lhi, lds, text, "\r", 0); text.Add("\r".ToCharArray()); for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } TextUtil.LHI_Insert(lhi, lds, text, "\n", 1); text.Add("\n".ToCharArray()); Assert.AreEqual("0 2", lhi.ToString()); Assert.AreEqual("CD", MakeLdsText(lds)); } // insert "\n" after '\r' at end of document (boundary check for LHI_Delete) { text.Clear(); lhi.Clear(); lhi.Add(0); lds.Clear(); lds.Add(LineDirtyState.Clean); TextUtil.LHI_Insert(lhi, lds, text, "\r\n", 0); text.Add("\r\n".ToCharArray()); for (int i = 0; i < lds.Count; i++) { lds[i] = LineDirtyState.Clean; } TextUtil.LHI_Delete(lhi, lds, text, 1, 2); text.RemoveRange(1, 2); Assert.AreEqual("0 1", lhi.ToString()); Assert.AreEqual("DD", MakeLdsText(lds)); } }
public void Replace() { const string InitData = "hogepiyo"; SplitArray <char> sary = new SplitArray <char>(5, 8); // replace position { // before head sary.Clear(); sary.Add(InitData.ToCharArray()); MyAssert.Throws <AssertException>(delegate { sary.Replace(-1, "000".ToCharArray(), 0, 2); }); // head sary.Clear(); sary.Add(InitData.ToCharArray()); sary.Replace(0, "000".ToCharArray(), 0, 2); Assert.AreEqual("00gepiyo", ToString(sary)); // middle sary.Clear(); sary.Add(InitData.ToCharArray()); sary.Replace(4, "000".ToCharArray(), 0, 2); Assert.AreEqual("hoge00yo", ToString(sary)); // end sary.Clear(); sary.Add(InitData.ToCharArray()); sary.Replace(6, "000".ToCharArray(), 0, 2); Assert.AreEqual("hogepi00", ToString(sary)); // after end sary.Clear(); sary.Add(InitData.ToCharArray()); MyAssert.Throws <AssertException>(delegate { sary.Replace(7, "000".ToCharArray(), 0, 2); }); MyAssert.Throws <AssertException>(delegate { sary.Replace(8, "000".ToCharArray(), 0, 2); }); } // value array { // giving null MyAssert.Throws <AssertException>(delegate { sary.Replace(0, null, 0, 1); }); // empty array sary.Replace(0, "".ToCharArray(), 0, 0); Assert.AreEqual("hogepiyo", ToString(sary)); // empty range sary.Replace(0, "000".ToCharArray(), 0, 0); Assert.AreEqual("hogepiyo", ToString(sary)); // invalid range (reversed) MyAssert.Throws <AssertException>(delegate { sary.Replace(0, "000".ToCharArray(), 1, 0); }); // invalid range (before head) MyAssert.Throws <AssertException>(delegate { sary.Replace(0, "000".ToCharArray(), -1, 0); }); // invalid range (after head) MyAssert.Throws <AssertException>(delegate { sary.Replace(0, "000".ToCharArray(), 3, 4); }); } }
public void GetSet() { RleArray <char> chars; // get chars = new RleArray <char>(); Set(chars, "abc"); Assert.AreEqual(3, chars.Count); Assert.AreEqual('a', chars[0]); Assert.AreEqual('b', chars[1]); Assert.AreEqual('c', chars[2]); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { chars[-1].ToString(); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { chars[5].ToString(); }); // set - out of bounds chars = new RleArray <char>(); Set(chars, "abc"); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { chars[-1] = 'z'; }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { chars[4] = 'd'; }); { // set - same value chars = new RleArray <char>(); Set(chars, "aabbbcc"); chars[2] = 'b'; Assert.AreEqual("a a b b b c c", chars.ToString()); Assert.AreEqual("[2|a] [3|b] [2|c]", chars._Nodes.ToString()); // set - new value on left boundary chars = new RleArray <char>(); Set(chars, "aabbbcc"); chars[2] = 'X'; Assert.AreEqual("a a X b b c c", chars.ToString()); Assert.AreEqual("[2|a] [1|X] [2|b] [2|c]", chars._Nodes.ToString()); // set - same value as the previous node on left boundary chars = new RleArray <char>(); Set(chars, "aabbbcc"); chars[2] = 'a'; Assert.AreEqual("a a a b b c c", chars.ToString()); Assert.AreEqual("[3|a] [2|b] [2|c]", chars._Nodes.ToString()); // set - new value in the middle of a node chars = new RleArray <char>(); Set(chars, "aabbbcc"); chars[3] = 'a'; Assert.AreEqual("a a b a b c c", chars.ToString()); Assert.AreEqual("[2|a] [1|b] [1|a] [1|b] [2|c]", chars._Nodes.ToString()); // set - new value on right boundary chars = new RleArray <char>(); Set(chars, "aabbbcc"); chars[4] = 'X'; Assert.AreEqual("a a b b X c c", chars.ToString()); Assert.AreEqual("[2|a] [2|b] [1|X] [2|c]", chars._Nodes.ToString()); // set - same value as the next node on right boundary chars = new RleArray <char>(); Set(chars, "aabbbcc"); chars[4] = 'c'; Assert.AreEqual("a a b b c c c", chars.ToString()); Assert.AreEqual("[2|a] [2|b] [3|c]", chars._Nodes.ToString()); } { // set - combines with previous node and the node disappears chars = new RleArray <char>(); Set(chars, "aabcc"); chars[2] = 'a'; Assert.AreEqual("a a a c c", chars.ToString()); Assert.AreEqual("[3|a] [2|c]", chars._Nodes.ToString()); // set - combines with next node and the node disappears chars = new RleArray <char>(); Set(chars, "aabcc"); chars[2] = 'c'; Assert.AreEqual("a a c c c", chars.ToString()); Assert.AreEqual("[2|a] [3|c]", chars._Nodes.ToString()); // set - combines with next and previous node, and the node disappears chars = new RleArray <char>(); Set(chars, "aabaa"); chars[2] = 'a'; Assert.AreEqual("a a a a a", chars.ToString()); Assert.AreEqual("[5|a]", chars._Nodes.ToString()); // set - combines with previous node and the node disappears chars = new RleArray <char>(); Set(chars, "aabcc"); chars[2] = 'B'; Assert.AreEqual("a a B c c", chars.ToString()); Assert.AreEqual("[2|a] [1|B] [2|c]", chars._Nodes.ToString()); } }
public void FindPrevR() { Document doc = new Document(); doc.Replace("abcdabcaba"); // black box test (interface test) { // null target MyAssert.Throws <ArgumentNullException>(delegate { doc.FindPrev((Regex)null, 0, 10); }); // negative index MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.FindPrev(new Regex("a", RegexOptions.RightToLeft), -1, 10); }); // invalid regex option MyAssert.Throws <ArgumentException>(delegate { doc.FindPrev(new Regex("a", RegexOptions.None), 0, doc.Length); }); // end index at out of range MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.FindPrev(new Regex("a", RegexOptions.RightToLeft), 0, doc.Length + 1); }); // inverted range MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.FindPrev(new Regex("a", RegexOptions.RightToLeft), 1, 0); }); // empty range Assert.AreEqual(null, doc.FindPrev(new Regex("a", RegexOptions.RightToLeft), 0, 0)); // find in valid range Assert.AreEqual(9, doc.FindPrev(new Regex("a", RegexOptions.RightToLeft), 0, 10).Begin); Assert.AreEqual(7, doc.FindPrev(new Regex("ab", RegexOptions.RightToLeft), 0, 10).Begin); Assert.AreEqual(4, doc.FindPrev(new Regex("abc", RegexOptions.RightToLeft), 0, 10).Begin); Assert.AreEqual(0, doc.FindPrev(new Regex("abcd", RegexOptions.RightToLeft), 0, 10).Begin); Assert.AreEqual(null, doc.FindPrev(new Regex("abcde", RegexOptions.RightToLeft), 0, 10)); // empty pattern (returns end index) Assert.AreEqual(10, doc.FindPrev(new Regex("", RegexOptions.RightToLeft), 0, 10).Begin); // comp. options Assert.AreEqual(null, doc.FindPrev(new Regex("aBcD", RegexOptions.RightToLeft), 0, 10)); Assert.AreEqual(0, doc.FindPrev(new Regex("aBcD", RegexOptions.RightToLeft | RegexOptions.IgnoreCase), 0, 10).Begin); } // white box test (test of the gap condition. test only result.) { // (buf: abcda......bcaba) // gap < begin MoveGap(doc, 5); Assert.AreEqual(7, doc.FindPrev(new Regex("ab", RegexOptions.RightToLeft), 7, 10).Begin); // gap == begin { MoveGap(doc, 5); Assert.AreEqual(7, doc.FindPrev(new Regex("ab", RegexOptions.RightToLeft), 5, 10).Begin); // word at the begin MoveGap(doc, 5); Assert.AreEqual(5, doc.FindPrev(new Regex("bc", RegexOptions.RightToLeft), 5, 10).Begin); // partially matched word but overruning boundary MoveGap(doc, 5); Assert.AreEqual(null, doc.FindPrev(new Regex("abca", RegexOptions.RightToLeft), 5, 10)); } // begin < gap < end { // word before the gap MoveGap(doc, 5); Assert.AreEqual(3, doc.FindPrev(new Regex("da", RegexOptions.RightToLeft), 0, 10).Begin); // word crossing the gap MoveGap(doc, 5); Assert.AreEqual(4, doc.FindPrev(new Regex("abc", RegexOptions.RightToLeft), 0, 10).Begin); // word after the gap MoveGap(doc, 5); Assert.AreEqual(5, doc.FindPrev(new Regex("bca", RegexOptions.RightToLeft), 0, 10).Begin); } // gap == end MoveGap(doc, 5); Assert.AreEqual(0, doc.FindPrev(new Regex("ab", RegexOptions.RightToLeft), 0, 5).Begin); // end <= gap MoveGap(doc, 5); Assert.AreEqual(0, doc.FindPrev(new Regex("ab", RegexOptions.RightToLeft), 0, 4).Begin); } }
public void FindNextR() { Document doc = new Document(); TextSegment result; doc.Replace("aababcabcd"); // black box test { // null argument MyAssert.Throws <ArgumentNullException>(delegate { doc.FindNext((Regex)null, 1, 2); }); // negative index MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.FindNext(new Regex("a[^b]+"), -1, 2); }); // inverted range MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.FindNext(new Regex("a[^b]+"), 2, 1); }); // empty range result = doc.FindNext(new Regex("a[^b]+"), 0, 0); Assert.AreEqual(null, result); // range exceeding text length MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.FindNext(new Regex("a[^b]+"), 1, 9999); }); // invalid Regex option MyAssert.Throws <ArgumentException>(delegate { doc.FindNext(new Regex("a[^b]+", RegexOptions.RightToLeft), 1, 4); }); // pattern ord at begin result = doc.FindNext(new Regex("a[^b]+"), 0, 2); Assert.AreEqual(0, result.Begin); Assert.AreEqual(2, result.End); // pattern in the range result = doc.FindNext(new Regex("a[^a]+"), 0, 3); Assert.AreEqual(1, result.Begin); Assert.AreEqual(3, result.End); // pattern which ends at end result = doc.FindNext(new Regex("[ab]+"), 0, 5); Assert.AreEqual(0, result.Begin); Assert.AreEqual(5, result.End); // pattern... well, pretty hard to describe in English for me... result = doc.FindNext(new Regex("[abc]+"), 0, 5); Assert.AreEqual(0, result.Begin); Assert.AreEqual(5, result.End); result = doc.FindNext(new Regex("[abc]+"), 0, 10); Assert.AreEqual(0, result.Begin); Assert.AreEqual(9, result.End); // empty pattern result = doc.FindNext(new Regex(""), 0, 10); Assert.AreEqual(0, result.Begin); Assert.AreEqual(0, result.End); // comp. options result = doc.FindNext(new Regex("aBcD"), 0, doc.Length); Assert.AreEqual(null, result); result = doc.FindNext(new Regex("aBcD", RegexOptions.IgnoreCase), 0, doc.Length); Assert.AreEqual(6, result.Begin); Assert.AreEqual(10, result.End); } // white box test (test of the gap condition. test only result.) { // (buf: aaba......bcabcd) // gap < begin MoveGap(doc, 4); Assert.AreEqual(6, doc.FindNext(new Regex("ab"), 5, doc.Length).Begin); // gap == begin MoveGap(doc, 4); Assert.AreEqual(6, doc.FindNext(new Regex("ab"), 4, doc.Length).Begin); // begin < gap < end { // word before the gap MoveGap(doc, 4); Assert.AreEqual(2, doc.FindNext(new Regex("ba"), 2, doc.Length).Begin); // word crossing the gap MoveGap(doc, 4); Assert.AreEqual(3, doc.FindNext(new Regex("ab"), 2, doc.Length).Begin); // word after the gap MoveGap(doc, 4); Assert.AreEqual(5, doc.FindNext(new Regex("cab"), 2, doc.Length).Begin); } // gap == end { MoveGap(doc, 4); Assert.AreEqual(1, doc.FindNext(new Regex("ab"), 0, 4).Begin); // word at the end MoveGap(doc, 4); Assert.AreEqual(2, doc.FindNext(new Regex("ba"), 0, 4).Begin); // partially matched word but overruning boundary MoveGap(doc, 4); Assert.AreEqual(null, doc.FindNext(new Regex("abc"), 0, 4)); } // end <= gap MoveGap(doc, 4); Assert.AreEqual(1, doc.FindNext(new Regex("ab"), 0, 4).Begin); } }
public void FindNext() { Document doc = new Document(); doc.Replace("aababcabcd"); // black box test (interface test) { // null target MyAssert.Throws <ArgumentNullException>(delegate { doc.FindNext((string)null, 0); }); // negative index MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.FindNext("a", -1); }); // end index at out of range MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.FindNext("a", 0, doc.Length + 1, true); }); // inverted range MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.FindNext("a", 1, 0, true); }); // empty range Assert.AreEqual(null, doc.FindNext("a", 0, 0, true)); // find in valid range Assert.AreEqual(0, doc.FindNext("a", 0, 1, true).Begin); Assert.AreEqual(1, doc.FindNext("ab", 0).Begin); Assert.AreEqual(3, doc.FindNext("abc", 0).Begin); Assert.AreEqual(6, doc.FindNext("abcd", 0).Begin); Assert.AreEqual(null, doc.FindNext("abcde", 0)); // empty pattern (returns begin index) Assert.AreEqual(1, doc.FindNext("", 1).Begin); // comp. options Assert.AreEqual(null, doc.FindNext("aBcD", 0, doc.Length, true)); Assert.AreEqual(6, doc.FindNext("aBcD", 0, doc.Length, false).Begin); } // white box test (test of the gap condition. test only result.) { // (buf: aaba......bcabcd) // gap < begin MoveGap(doc, 4); Assert.AreEqual(6, doc.FindNext("ab", 5, doc.Length, true).Begin); // gap == begin MoveGap(doc, 4); Assert.AreEqual(6, doc.FindNext("ab", 4, doc.Length, true).Begin); // begin < gap < end { // word before the gap MoveGap(doc, 4); Assert.AreEqual(2, doc.FindNext("ba", 2, doc.Length, true).Begin); // word crossing the gap MoveGap(doc, 4); Assert.AreEqual(3, doc.FindNext("ab", 2, doc.Length, true).Begin); // word after the gap MoveGap(doc, 4); Assert.AreEqual(5, doc.FindNext("cab", 2, doc.Length, true).Begin); } // gap == end { MoveGap(doc, 4); Assert.AreEqual(1, doc.FindNext("ab", 0, 4, true).Begin); // word at the end MoveGap(doc, 4); Assert.AreEqual(2, doc.FindNext("ba", 0, 4, true).Begin); // partially matched word but overruning boundary MoveGap(doc, 4); Assert.AreEqual(null, doc.FindNext("abc", 0, 4, true)); } // end <= gap MoveGap(doc, 4); Assert.AreEqual(1, doc.FindNext("ab", 0, 4, true).Begin); } }
public void Selection() { Document doc = new Document(); int begin, end; doc.Text = "臼と似た形をした文字「\xd85a\xdd51」は、UCS 文字空間の第2面に位置する"; // before head to head MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.SetSelection(-1, 0); }); // head to head doc.SetSelection(0, 0); doc.GetSelection(out begin, out end); Assert.AreEqual(begin, 0); Assert.AreEqual(end, 0); // head to before hi-surrogate doc.SetSelection(0, 4); doc.GetSelection(out begin, out end); Assert.AreEqual(begin, 0); Assert.AreEqual(end, 4); // before hi-surrogate to lo-surrogate doc.SetSelection(4, 11); doc.GetSelection(out begin, out end); Assert.AreEqual(begin, 4); Assert.AreEqual(end, 11); // hi-surrogate to lo-surrogate doc.SetSelection(11, 12); doc.GetSelection(out begin, out end); Assert.AreEqual(begin, 11); Assert.AreEqual(end, 13); // surely expanded? // hi-surrogate to after lo-surrogate doc.SetSelection(11, 13); doc.GetSelection(out begin, out end); Assert.AreEqual(begin, 11); Assert.AreEqual(end, 13); // middle of the surrogate pair // ('moving caret between the pair' must be treated as 'moving caret to the *char*') doc.SetSelection(12, 12); doc.GetSelection(out begin, out end); Assert.AreEqual(begin, 11); Assert.AreEqual(end, 11); // lo-surrogate to after lo-surrogate doc.SetSelection(12, 13); doc.GetSelection(out begin, out end); Assert.AreEqual(begin, 11); Assert.AreEqual(end, 13); // after lo-surrogate to end doc.SetSelection(13, 33); doc.GetSelection(out begin, out end); Assert.AreEqual(begin, 13); Assert.AreEqual(end, 33); // end to after end MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.SetSelection(33, 36); }); }
public void Replace() { Document doc = new Document(); doc.Text = "keep it as simple as possible\r\nbut\nnot simpler."; // empty range (1) doc.Replace("n\r", 8, 8); Assert.AreEqual("keep it n\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(0, doc.AnchorIndex); Assert.AreEqual(0, doc.CaretIndex); // empty range (2) doc.SetSelection(9, 9); doc.Replace("ot"); Assert.AreEqual("keep it not\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(11, doc.AnchorIndex); Assert.AreEqual(11, doc.CaretIndex); // invalid range (before begin to middle) MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.Replace("FOO", -1, 10); }); // valid range (begin to middle) { // replace to same length (1) doc.SetSelection(0, 4); doc.Replace("KEP"); Assert.AreEqual("KEP it not\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(3, doc.AnchorIndex); Assert.AreEqual(3, doc.CaretIndex); // replace to same length (2) doc.Replace("Keep", 0, 3); Assert.AreEqual("Keep it not\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(4, doc.AnchorIndex); Assert.AreEqual(4, doc.CaretIndex); // replace to longer (1) doc.SetSelection(0, 3); doc.Replace("KEEP!"); Assert.AreEqual("KEEP!p it not\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(5, doc.AnchorIndex); Assert.AreEqual(5, doc.CaretIndex); // replace to longer (2) doc.Replace("Keeeeep", 0, 6); Assert.AreEqual("Keeeeep it not\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(7, doc.AnchorIndex); Assert.AreEqual(7, doc.CaretIndex); // replace to shorter (1) doc.SetSelection(0, 7); doc.Replace("KEEEP"); Assert.AreEqual("KEEEP it not\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(5, doc.AnchorIndex); Assert.AreEqual(5, doc.CaretIndex); // replace to shorter (2) doc.Replace("Keep", 0, 5); Assert.AreEqual("Keep it not\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(4, doc.AnchorIndex); Assert.AreEqual(4, doc.CaretIndex); } // valid range (middle to middle) { // replace to same length (1) doc.Replace("ZIMPLE", 15, 21); Assert.AreEqual("Keep it not\ras ZIMPLE as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(4, doc.AnchorIndex); Assert.AreEqual(4, doc.CaretIndex); // replace to same length (2) doc.SetSelection(15, 21); doc.Replace("SIMPLE"); Assert.AreEqual("Keep it not\ras SIMPLE as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(21, doc.AnchorIndex); Assert.AreEqual(21, doc.CaretIndex); // replace to longer (1) doc.SetSelection(14, 15); doc.Replace("COMPLEX", 15, 21); Assert.AreEqual("Keep it not\ras COMPLEX as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(14, doc.AnchorIndex); Assert.AreEqual(22, doc.CaretIndex); // replace to longer (2) doc.SetSelection(19, 22); doc.Replace("LEX!"); Assert.AreEqual("Keep it not\ras COMPLEX! as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(23, doc.AnchorIndex); Assert.AreEqual(23, doc.CaretIndex); // replace to shorter (1) doc.Replace("simple!", 15, 23); Assert.AreEqual("Keep it not\ras simple! as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(22, doc.AnchorIndex); Assert.AreEqual(22, doc.CaretIndex); // replace to shorter (2) doc.SetSelection(15, 22); doc.Replace("simple"); Assert.AreEqual("Keep it not\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(21, doc.AnchorIndex); Assert.AreEqual(21, doc.CaretIndex); } // valid range (middle to end) { // replace to same length (1) doc.Replace("?", 50, 51); Assert.AreEqual("Keep it not\ras simple as possible\r\nbut\nnot simpler?", doc.Text); Assert.AreEqual(21, doc.AnchorIndex); Assert.AreEqual(21, doc.CaretIndex); // replace to same length (2) doc.SetSelection(50, 51); doc.Replace("!"); Assert.AreEqual("Keep it not\ras simple as possible\r\nbut\nnot simpler!", doc.Text); Assert.AreEqual(51, doc.AnchorIndex); Assert.AreEqual(51, doc.CaretIndex); // replace to longer (1) doc.Replace("??", 50, 51); Assert.AreEqual("Keep it not\ras simple as possible\r\nbut\nnot simpler??", doc.Text); Assert.AreEqual(52, doc.AnchorIndex); Assert.AreEqual(52, doc.CaretIndex); // replace to longer (2) doc.Replace("!!!", 50, 52); Assert.AreEqual("Keep it not\ras simple as possible\r\nbut\nnot simpler!!!", doc.Text); Assert.AreEqual(53, doc.AnchorIndex); Assert.AreEqual(53, doc.CaretIndex); // replace to shorter (1) doc.Replace("..", 50, 53); Assert.AreEqual("Keep it not\ras simple as possible\r\nbut\nnot simpler..", doc.Text); Assert.AreEqual(52, doc.AnchorIndex); Assert.AreEqual(52, doc.CaretIndex); // replace to shorter (2) doc.Replace(".", 50, 52); Assert.AreEqual("Keep it not\ras simple as possible\r\nbut\nnot simpler.", doc.Text); Assert.AreEqual(51, doc.AnchorIndex); Assert.AreEqual(51, doc.CaretIndex); } // invalid range (middle to after end) MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.Replace("PIYO", 51, 53); }); }
public void DocumentDirtyState() { // dirty state { Document doc = new Document(); Assert.AreEqual(false, doc.IsDirty); doc.Replace("a", 0, 0); Assert.AreEqual(true, doc.IsDirty); Assert.AreEqual("a", doc.Text); doc.IsDirty = false; Assert.AreEqual(false, doc.IsDirty); Assert.AreEqual("a", doc.Text); doc.BeginUndo(); Assert.AreEqual(false, doc.IsDirty); Assert.AreEqual("a", doc.Text); doc.Replace("b", 1, 1); Assert.AreEqual(true, doc.IsDirty); Assert.AreEqual("ab", doc.Text); doc.Replace("c", 2, 2); Assert.AreEqual(true, doc.IsDirty); Assert.AreEqual("abc", doc.Text); doc.EndUndo(); Assert.AreEqual(true, doc.IsDirty); Assert.AreEqual("abc", doc.Text); doc.Undo(); Assert.AreEqual(false, doc.IsDirty); Assert.AreEqual("a", doc.Text); doc.Undo(); Assert.AreEqual(true, doc.IsDirty); Assert.AreEqual("", doc.Text); doc.Redo(); Assert.AreEqual(false, doc.IsDirty); Assert.AreEqual("a", doc.Text); doc.Undo(); doc.Replace("a", 0, 0); Assert.AreEqual(true, doc.IsDirty); Assert.AreEqual("a", doc.Text); } // change IsDirty flag while recording group UNDO { Document doc = new Document(); doc.BeginUndo(); MyAssert.Throws <InvalidOperationException>(delegate { doc.IsDirty = true; }); } // special case; BeginUndo at initial state // ([*] goes exceptional 'if' code in EditHistory.IsSavedState) { Document doc = new Document(); Assert.AreEqual(false, doc.IsDirty); doc.BeginUndo(); Assert.AreEqual(false, doc.IsDirty); doc.Replace("a", 0, 0); Assert.AreEqual(true, doc.IsDirty); // [*] doc.EndUndo(); Assert.AreEqual(true, doc.IsDirty); } }
public void Keywords() { Document doc = new Document(); KeywordHighlighter h = new KeywordHighlighter(); h.AddEnclosure("\"", "\"", CharClass.String, '\\'); h.AddEnclosure("/*", "*/", CharClass.Comment); h.AddKeywordSet(new string[] { "for", "if", "int", "interface", "join" }, CharClass.Keyword); doc.Highlighter = h; //--------------------------------------------- int i; // "int" --> "int " doc.Text = "int"; h.Highlight(doc); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } doc.Replace(" ", 3, 3); h.Highlight(doc); Assert.AreEqual("int ", doc.Text); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } for ( ; i < 4; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(4); }); // "int" --> "-int" doc.Text = "int"; h.Highlight(doc); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } doc.Replace("-", 0, 0); h.Highlight(doc); Assert.AreEqual("-int", doc.Text); for (i = 0; i < 1; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } for ( ; i < 4; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(4); }); // in --> int doc.Text = "in"; h.Highlight(doc); for (i = 0; i < 2; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } doc.Replace("t", 2, 2); h.Highlight(doc); Assert.AreEqual("int", doc.Text); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(3); }); // it --> int doc.Text = "it"; h.Highlight(doc); for (i = 0; i < 2; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } doc.Replace("n", 1, 1); h.Highlight(doc); Assert.AreEqual("int", doc.Text); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(3); }); // nt --> int doc.Text = "nt"; h.Highlight(doc); for (i = 0; i < 2; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } doc.Replace("i", 0, 0); h.Highlight(doc); Assert.AreEqual("int", doc.Text); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(3); }); // "insert at" --> int doc.Text = "insert at"; h.Highlight(doc); for (i = 0; i < 9; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } doc.Replace("n", 1, 8); h.Highlight(doc); Assert.AreEqual("int", doc.Text); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(3); }); // "hoge" --> "h int e" doc.Text = "hoge"; h.Highlight(doc); for (i = 0; i < 4; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } doc.Replace(" int ", 1, 3); h.Highlight(doc); Assert.AreEqual("h int e", doc.Text); for (i = 0; i < 2; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } for ( ; i < 5; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } for ( ; i < 7; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(7); }); // "int" --> "if!" doc.Text = "int"; h.Highlight(doc); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } doc.Replace("f!", 1, 3); h.Highlight(doc); Assert.AreEqual("if!", doc.Text); for (i = 0; i < 2; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } for ( ; i < 3; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(3); }); // "int" --> "inte" doc.Text = "int"; h.Highlight(doc); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } doc.Replace("e", 3, 3); h.Highlight(doc); Assert.AreEqual("inte", doc.Text); for (i = 0; i < 4; i++) { Assert.AreEqual(CharClass.Normal, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(4); }); // "int" --> "interface" doc.Text = "int"; h.Highlight(doc); for (i = 0; i < 3; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } doc.Replace("erface", 3, 3); h.Highlight(doc); Assert.AreEqual("interface", doc.Text); for (i = 0; i < 9; i++) { Assert.AreEqual(CharClass.Keyword, doc.GetCharClass(i)); } MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetCharClass(10); }); }
public void WordDetection() { Document doc = new Document(); DefaultWordProc wordProc = new DefaultWordProc(); string[] samples = new string[] { "aa", "11", ",,", "\x3042\x3042", "\x963f\x963f", "\n\n", " " }; int[] expected; int[] expectedForSameClass; // NextWordStart expected = new int[] { 0, 2, 2, 4, 4 }; expectedForSameClass = new int[] { 0, 4, 4, 4, 4 }; for (int left = 0; left < samples.Length; left++) { for (int right = 0; right < samples.Length; right++) { doc.Text = samples[left] + samples[right]; for (int i = 0; i < doc.Length; i++) { int actual = wordProc.NextWordStart(doc, i); if (left == right) { Assert.AreEqual(expectedForSameClass[i], actual); } else { Assert.AreEqual(expected[i], actual); } } } } Assert.AreEqual(doc.Length, wordProc.NextWordStart(doc, doc.Length)); // combining character doc.Text = ".a\x0300."; Assert.AreEqual(1, wordProc.NextWordStart(doc, 1)); Assert.AreEqual(3, wordProc.NextWordStart(doc, 2)); Assert.AreEqual(3, wordProc.NextWordStart(doc, 3)); // combining character doc.Text = "aa\x0300a"; Assert.AreEqual(4, wordProc.NextWordStart(doc, 1)); Assert.AreEqual(4, wordProc.NextWordStart(doc, 2)); Assert.AreEqual(4, wordProc.NextWordStart(doc, 3)); MyAssert.Throws <ArgumentNullException>(delegate { wordProc.NextWordStart(null, 0); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { wordProc.NextWordStart(doc, -1); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { wordProc.NextWordStart(doc, doc.Length + 1); }); // NextWordEnd expected = new int[] { 2, 2, 2, 4, 4 }; expectedForSameClass = new int[] { 4, 4, 4, 4, 4 }; for (int left = 0; left < samples.Length; left++) { for (int right = 0; right < samples.Length; right++) { doc.Text = samples[left] + samples[right]; for (int i = 0; i < doc.Length; i++) { int actual = wordProc.NextWordEnd(doc, i); if (left == right) { Assert.AreEqual(expectedForSameClass[i], actual); } else { Assert.AreEqual(expected[i], actual); } } } } Assert.AreEqual(doc.Length, wordProc.NextWordEnd(doc, doc.Length)); // combining character doc.Text = ".a\x0300."; Assert.AreEqual(1, wordProc.NextWordEnd(doc, 1)); Assert.AreEqual(3, wordProc.NextWordEnd(doc, 2)); Assert.AreEqual(3, wordProc.NextWordEnd(doc, 3)); // combining character doc.Text = "aa\x0300a"; Assert.AreEqual(4, wordProc.NextWordEnd(doc, 1)); Assert.AreEqual(4, wordProc.NextWordEnd(doc, 2)); Assert.AreEqual(4, wordProc.NextWordEnd(doc, 3)); MyAssert.Throws <ArgumentNullException>(delegate { wordProc.NextWordEnd(null, 0); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { wordProc.NextWordEnd(doc, -1); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { wordProc.NextWordEnd(doc, doc.Length + 1); }); // PrevWordStart expected = new int[] { 0, 0, 2, 2, 4 }; expectedForSameClass = new int[] { 0, 0, 0, 0, 4 }; for (int left = 0; left < samples.Length; left++) { for (int right = 0; right < samples.Length; right++) { doc.Text = samples[left] + samples[right]; for (int i = 0; i < doc.Length; i++) { int actual = wordProc.PrevWordStart(doc, i); if (left == right) { Assert.AreEqual(expectedForSameClass[i], actual); } else { Assert.AreEqual(expected[i], actual); } } } } Assert.AreEqual(doc.Length, wordProc.PrevWordStart(doc, doc.Length)); // combining character doc.Text = ".a\x0300."; Assert.AreEqual(1, wordProc.PrevWordStart(doc, 1)); Assert.AreEqual(1, wordProc.PrevWordStart(doc, 2)); Assert.AreEqual(3, wordProc.PrevWordStart(doc, 3)); // combining character doc.Text = "aa\x0300a"; Assert.AreEqual(0, wordProc.PrevWordStart(doc, 1)); Assert.AreEqual(0, wordProc.PrevWordStart(doc, 2)); Assert.AreEqual(0, wordProc.PrevWordStart(doc, 3)); MyAssert.Throws <ArgumentNullException>(delegate { wordProc.PrevWordStart(null, 0); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { wordProc.PrevWordStart(doc, -1); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { wordProc.PrevWordStart(doc, doc.Length + 1); }); // PrevWordEnd expected = new int[] { 0, 0, 2, 2, 4 }; expectedForSameClass = new int[] { 0, 0, 0, 0, 4 }; for (int left = 0; left < samples.Length; left++) { for (int right = 0; right < samples.Length; right++) { doc.Text = samples[left] + samples[right]; for (int i = 0; i < doc.Length; i++) { int actual = wordProc.PrevWordEnd(doc, i); if (left == right) { Assert.AreEqual(expectedForSameClass[i], actual); } else { Assert.AreEqual(expected[i], actual); } } } } Assert.AreEqual(doc.Length, wordProc.PrevWordEnd(doc, doc.Length)); // combining character doc.Text = ".a\x0300."; Assert.AreEqual(1, wordProc.PrevWordEnd(doc, 1)); Assert.AreEqual(1, wordProc.PrevWordEnd(doc, 2)); Assert.AreEqual(3, wordProc.PrevWordEnd(doc, 3)); // combining character doc.Text = "aa\x0300a"; Assert.AreEqual(0, wordProc.PrevWordEnd(doc, 1)); Assert.AreEqual(0, wordProc.PrevWordEnd(doc, 2)); Assert.AreEqual(0, wordProc.PrevWordEnd(doc, 3)); MyAssert.Throws <ArgumentNullException>(delegate { wordProc.PrevWordEnd(null, 0); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { wordProc.PrevWordEnd(doc, -1); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { wordProc.PrevWordEnd(doc, doc.Length + 1); }); }
public void GetTextInRange() { // keep it\r // as simple as possible\r\n // but\n // not simpler. Document doc = new Document(); doc.Text = "keep it\ras simple as possible\r\nbut\nnot simpler."; // char-index type { // invalid range (before begin to middle) MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(-1, 4); }); // valid range (begin to middle) Assert.AreEqual("ke", doc.GetTextInRange(0, 2)); // valid range (middle to middle) Assert.AreEqual("ep it", doc.GetTextInRange(2, 7)); // valid range (middle to end) Assert.AreEqual("simpler.", doc.GetTextInRange(39, 47)); // invalid range (middle to after end) MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(39, 48); }); // invalid range (minus range) MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(10, 9); }); } // line/column index type { // invalid range (before begin to middle) MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(-1, -1, 1, 1); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(-1, 0, 1, 1); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(1, -1, 1, 1); }); // valid range (empty range) Assert.AreEqual("", doc.GetTextInRange(0, 0, 0, 0)); Assert.AreEqual("", doc.GetTextInRange(1, 1, 1, 1)); // valid range (begin to middle) Assert.AreEqual("ke", doc.GetTextInRange(0, 0, 0, 2)); Assert.AreEqual("ee", doc.GetTextInRange(0, 1, 0, 3)); Assert.AreEqual("as", doc.GetTextInRange(1, 0, 1, 2)); // valid range (middle to middle) Assert.AreEqual("s simple as possible\r\nbut\nn", doc.GetTextInRange(1, 1, 3, 1)); // valid range (middle to end) Assert.AreEqual("t\nnot simpler.", doc.GetTextInRange(2, 2, 3, 12)); // invalid range (middle to after end) MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(2, 2, 3, 13); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(2, 2, 4, 0); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(2, 2, 4, 13); }); // invalid range (minus range) MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(1, 1, 1, 0); }); MyAssert.Throws <ArgumentOutOfRangeException>(delegate { doc.GetTextInRange(1, 1, 0, 0); }); } }