public void Clear()
{
SplitArray <char> chars = new SplitArray <char>(5, 8);
chars.Clear();
Assert.AreEqual(0, chars.Count);
for (int x = 0; x < 10; x++)
{
MyAssert.Throws <AssertException>(delegate {
chars.GetAt(x);
});
MyAssert.Throws <AssertException>(delegate {
chars.SetAt('!', x);
});
}
chars.Add("hoge".ToCharArray());
chars.Clear();
Assert.AreEqual(0, chars.Count);
for (int x = 0; x < 10; x++)
{
MyAssert.Throws <AssertException>(delegate {
chars.GetAt(x);
});
MyAssert.Throws <AssertException>(delegate {
chars.SetAt('!', x);
});
}
}
public void BinarySearch()
{
SplitArray <int> ary = new SplitArray <int>(4);
ary.Clear();
Assert.AreEqual(-1, ary.BinarySearch(1234));
ary.Clear();
ary.Add(3);
Assert.AreEqual(~(0), ary.BinarySearch(2));
Assert.AreEqual((0), ary.BinarySearch(3));
Assert.AreEqual(~(1), ary.BinarySearch(4));
ary.Clear();
ary.Add(1, 3);
Assert.AreEqual(~(0), ary.BinarySearch(0));
Assert.AreEqual((0), ary.BinarySearch(1));
Assert.AreEqual(~(1), ary.BinarySearch(2));
Assert.AreEqual((1), ary.BinarySearch(3));
Assert.AreEqual(~(2), ary.BinarySearch(4));
SplitArray <System.Drawing.Point> points = new SplitArray <System.Drawing.Point>(4);
points.Add(new System.Drawing.Point());
MyAssert.Throws <ArgumentException>(delegate {
points.BinarySearch(new System.Drawing.Point(1, 1));
});
}
static void Test_BinarySearch()
{
SplitArray <int> ary = new SplitArray <int>(4);
ary.Clear();
TestUtl.AssertEquals(-1, ary.BinarySearch(1234));
ary.Clear();
ary.Add(3);
TestUtl.AssertEquals(~(0), ary.BinarySearch(2));
TestUtl.AssertEquals((0), ary.BinarySearch(3));
TestUtl.AssertEquals(~(1), ary.BinarySearch(4));
ary.Clear();
ary.Add(1, 3);
TestUtl.AssertEquals(~(0), ary.BinarySearch(0));
TestUtl.AssertEquals((0), ary.BinarySearch(1));
TestUtl.AssertEquals(~(1), ary.BinarySearch(2));
TestUtl.AssertEquals((1), ary.BinarySearch(3));
TestUtl.AssertEquals(~(2), ary.BinarySearch(4));
SplitArray <System.Drawing.Point> points = new SplitArray <System.Drawing.Point>(4);
points.Add(new System.Drawing.Point());
try
{
points.BinarySearch(new System.Drawing.Point(1, 1));
throw new AssertException();
}
catch (Exception ex)
{
TestUtl.AssertExceptionType <ArgumentException>(ex);
}
}
static void Test_Clear()
{
SplitArray <char> chars = new SplitArray <char>(5, 8);
chars.Clear();
TestUtl.AssertEquals(0, chars.Count);
for (int x = 0; x < 10; x++)
{
try{ chars.GetAt(x); Debug.Fail("exception must be thrown here."); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
try{ chars.SetAt('!', x); Debug.Fail("exception must be thrown here."); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
}
chars.Add("hoge".ToCharArray());
chars.Clear();
TestUtl.AssertEquals(0, chars.Count);
for (int x = 0; x < 10; x++)
{
try{ chars.GetAt(x); Debug.Fail("exception must be thrown here."); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
try{ chars.SetAt('!', x); Debug.Fail("exception must be thrown here."); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
}
}
public void TestMethod5()
{
int[] arr = { 1, 2, 3, 4, 5 };
SplitArray sa = new SplitArray();
bool result = sa.isSumEqual(arr);
// Expected false
Assert.AreEqual(false, result);
}
public void RemoveRange()
{
const string InitData = "hogepiyo";
SplitArray <char> chars = new SplitArray <char>(5, 8);
// case 2 (moving gap to buffer head)
chars.Add(InitData.ToCharArray());
chars.RemoveAt(2);
Assert.AreEqual(7, chars.Count);
Assert.AreEqual("hoepiyo", ToString(chars));
MyAssert.Throws <AssertException>(delegate {
chars.GetAt(7);
});
// case 1 (moving gap to buffer end)
chars.Clear();
chars.Add(InitData.ToCharArray());
chars.RemoveRange(5, 7);
Assert.AreEqual(6, chars.Count);
Assert.AreEqual("hogepo", ToString(chars));
MyAssert.Throws <AssertException>(delegate {
chars.GetAt(6);
});
// before head to middle
chars.Clear();
chars.Add(InitData.ToCharArray());
MyAssert.Throws <AssertException>(delegate {
chars.RemoveRange(-1, 2);
});
// head to middle
chars.Clear();
chars.Add(InitData.ToCharArray());
chars.RemoveRange(0, 2);
Assert.AreEqual("gepiyo", ToString(chars));
// middle to middle
chars.Clear();
chars.Add(InitData.ToCharArray());
chars.RemoveRange(2, 5);
Assert.AreEqual("hoiyo", ToString(chars));
// middle to end
chars.Clear();
chars.Add(InitData.ToCharArray());
chars.RemoveRange(5, 8);
Assert.AreEqual("hogep", ToString(chars));
// middle to after end
chars.Clear();
chars.Add(InitData.ToCharArray());
MyAssert.Throws <AssertException>(delegate {
chars.RemoveRange(5, 9);
});
}
public void TestMethod1()
{
int[] arr = { 1, 1, 2, 3, 4, 5, 6 };
SplitArray sa = new SplitArray();
bool result = sa.isSumEqual(arr);
// Expected true
// {1,1,2,3,4} and {5,6} => sum = 11
Assert.AreEqual(true, result);
}
public void TestMethod2()
{
int[] arr = { 1, 3, 2, 6 };
SplitArray sa = new SplitArray();
bool result = sa.isSumEqual(arr);
// Expected true
// {1,3,2} and {6} => sum = 6
Assert.AreEqual(true, result);
}
static void MakeTestData(out TextBuffer text, out SplitArray <int> lhi, out SplitArray <LineDirtyState> lds)
{
text = new TextBuffer(1, 1);
lhi = new SplitArray <int>(1, 8);
lds = new SplitArray <LineDirtyState>(1);
lhi.Add(0);
lds.Add(LineDirtyState.Clean);
TextUtil.LHI_Insert(lhi, lds, text, TestData, 0);
text.Insert(0, TestData.ToCharArray());
}
public void Insert_Array()
{
const string InitData = "hogepiyo";
SplitArray <char> sary = new SplitArray <char>(5, 8);
// null array
sary.Clear();
sary.Add(InitData.ToCharArray());
MyAssert.Throws <AssertException>(delegate {
sary.Insert(0, null);
});
// empty array
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(0, "".ToCharArray());
Assert.AreEqual("hogepiyo", ToString(sary));
// before head
sary.Clear();
sary.Add(InitData.ToCharArray());
MyAssert.Throws <AssertException>(delegate {
sary.Insert(-1, "FOO".ToCharArray());
});
// head
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(0, "FOO".ToCharArray());
Assert.AreEqual(11, sary.Count);
Assert.AreEqual("FOOhogepiyo", ToString(sary));
// middle
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(4, "FOO".ToCharArray());
Assert.AreEqual(11, sary.Count);
Assert.AreEqual("hogeFOOpiyo", ToString(sary));
// end
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(8, "FOO".ToCharArray());
Assert.AreEqual(11, sary.Count);
Assert.AreEqual("hogepiyoFOO", ToString(sary));
// after end
sary.Clear();
sary.Add(InitData.ToCharArray());
MyAssert.Throws <AssertException>(delegate {
sary.Insert(9, "FOO".ToCharArray());
});
}
static void Test_Add()
{
SplitArray <char> chars = new SplitArray <char>(5, 8);
chars.Add('a');
TestUtl.AssertEquals(1, chars.Count);
TestUtl.AssertEquals('a', chars.GetAt(0));
chars.SetAt('b', 0);
TestUtl.AssertEquals('b', chars.GetAt(0));
try{ chars.GetAt(1); Debug.Fail("exception must be thrown here."); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
}
public void CopyTo()
{
const string initBufContent = "123456";
SplitArray <char> sary = new SplitArray <char>(5, 8);
char[] buf;
sary.Insert(0, "hogepiyo".ToCharArray());
// before head to middle
buf = initBufContent.ToCharArray();
MyAssert.Throws <AssertException>(delegate {
sary.CopyTo(-1, 5, buf);
});
// begin to middle
buf = initBufContent.ToCharArray();
sary.CopyTo(0, 5, buf);
Assert.AreEqual("hogep6", new String(buf));
// middle to middle
buf = initBufContent.ToCharArray();
sary.CopyTo(1, 5, buf);
Assert.AreEqual("ogep56", new String(buf));
// middle to end
buf = initBufContent.ToCharArray();
sary.CopyTo(5, 8, buf);
Assert.AreEqual("iyo456", new String(buf));
// end to after end
buf = initBufContent.ToCharArray();
MyAssert.Throws <AssertException>(delegate {
sary.CopyTo(5, 9, buf);
});
// Range before the gap
MoveGap(sary, 2);
buf = initBufContent.ToCharArray();
sary.CopyTo(0, 1, buf);
Assert.AreEqual("h23456", new String(buf));
// Range including the gap
MoveGap(sary, 2);
buf = initBufContent.ToCharArray();
sary.CopyTo(0, 4, buf);
Assert.AreEqual("hoge56", new String(buf));
// Range after the gap
MoveGap(sary, 2);
buf = initBufContent.ToCharArray();
sary.CopyTo(4, 8, buf);
Assert.AreEqual("piyo56", new String(buf));
}
static void Test_RemoveRange()
{
const string InitData = "hogepiyo";
SplitArray <char> chars = new SplitArray <char>(5, 8);
// case 2 (moving gap to buffer head)
chars.Add(InitData.ToCharArray());
chars.RemoveAt(2);
TestUtl.AssertEquals(7, chars.Count);
TestUtl.AssertEquals("hoepiyo", ToString(chars));
try{ chars.GetAt(7); Console.WriteLine("!!!!!!!!!!!!!!!!!!!!!"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// case 1 (moving gap to buffer end)
chars.Clear();
chars.Add(InitData.ToCharArray());
chars.RemoveRange(5, 7);
TestUtl.AssertEquals(6, chars.Count);
TestUtl.AssertEquals("hogepo", ToString(chars));
try{ chars.GetAt(6); Console.WriteLine("!!!!!!!!!!!!!!!!!!!!!"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// before head to middle
chars.Clear();
chars.Add(InitData.ToCharArray());
try{ chars.RemoveRange(-1, 2); Debug.Fail("Exception wasn't thrown as expected."); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// head to middle
chars.Clear();
chars.Add(InitData.ToCharArray());
chars.RemoveRange(0, 2);
TestUtl.AssertEquals("gepiyo", ToString(chars));
// middle to middle
chars.Clear();
chars.Add(InitData.ToCharArray());
chars.RemoveRange(2, 5);
TestUtl.AssertEquals("hoiyo", ToString(chars));
// middle to end
chars.Clear();
chars.Add(InitData.ToCharArray());
chars.RemoveRange(5, 8);
TestUtl.AssertEquals("hogep", ToString(chars));
// middle to after end
chars.Clear();
chars.Add(InitData.ToCharArray());
try{ chars.RemoveRange(5, 9); Debug.Fail("Exception wasn't thrown as expected."); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
}
static void Test_Init()
{
SplitArray <char> chars = new SplitArray <char>(5, 8);
TestUtl.AssertEquals(0, chars.Count);
for (int x = 0; x < 10; x++)
{
try{ chars.GetAt(x); Debug.Fail("exception must be thrown here. (index:" + x + ")"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
try{ chars.SetAt('!', x); Debug.Fail("exception must be thrown here. (index:" + x + ")"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
}
}
public void Add()
{
SplitArray <char> chars = new SplitArray <char>(5, 8);
chars.Add('a');
Assert.AreEqual(1, chars.Count);
Assert.AreEqual('a', chars.GetAt(0));
chars.SetAt('b', 0);
Assert.AreEqual('b', chars.GetAt(0));
MyAssert.Throws <AssertException>(delegate {
chars.GetAt(1);
});
}
static void Test_CopyTo()
{
const string initBufContent = "123456";
SplitArray <char> sary = new SplitArray <char>(5, 8);
char[] buf;
sary.Insert(0, "hogepiyo".ToCharArray());
// before head to middle
buf = initBufContent.ToCharArray();
try{ sary.CopyTo(-1, 5, buf); Debug.Fail("Exception wasn't thrown as expected."); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// begin to middle
buf = initBufContent.ToCharArray();
sary.CopyTo(0, 5, buf);
TestUtl.AssertEquals("hogep6", new String(buf));
// middle to middle
buf = initBufContent.ToCharArray();
sary.CopyTo(1, 5, buf);
TestUtl.AssertEquals("ogep56", new String(buf));
// middle to end
buf = initBufContent.ToCharArray();
sary.CopyTo(5, 8, buf);
TestUtl.AssertEquals("iyo456", new String(buf));
// end to after end
buf = initBufContent.ToCharArray();
try{ sary.CopyTo(5, 9, buf); Debug.Fail("Exception wasn't thrown as expected."); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// Range before the gap
MoveGap(sary, 2);
buf = initBufContent.ToCharArray();
sary.CopyTo(0, 1, buf);
TestUtl.AssertEquals("h23456", new String(buf));
// Range including the gap
MoveGap(sary, 2);
buf = initBufContent.ToCharArray();
sary.CopyTo(0, 4, buf);
TestUtl.AssertEquals("hoge56", new String(buf));
// Range after the gap
MoveGap(sary, 2);
buf = initBufContent.ToCharArray();
sary.CopyTo(4, 8, buf);
TestUtl.AssertEquals("piyo56", new String(buf));
}
static void Test_Insert_Array()
{
const string InitData = "hogepiyo";
SplitArray <char> sary = new SplitArray <char>(5, 8);
// null array
sary.Clear();
sary.Add(InitData.ToCharArray());
try{ sary.Insert(0, null); Console.WriteLine("### INSA_NULL ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// empty array
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(0, "".ToCharArray());
TestUtl.AssertEquals("hogepiyo", ToString(sary));
// before head
sary.Clear();
sary.Add(InitData.ToCharArray());
try{ sary.Insert(-1, "FOO".ToCharArray()); Console.WriteLine("### INSA_BH ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// head
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(0, "FOO".ToCharArray());
TestUtl.AssertEquals(11, sary.Count);
TestUtl.AssertEquals("FOOhogepiyo", ToString(sary));
// middle
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(4, "FOO".ToCharArray());
TestUtl.AssertEquals(11, sary.Count);
TestUtl.AssertEquals("hogeFOOpiyo", ToString(sary));
// end
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(8, "FOO".ToCharArray());
TestUtl.AssertEquals(11, sary.Count);
TestUtl.AssertEquals("hogepiyoFOO", ToString(sary));
// after end
sary.Clear();
sary.Add(InitData.ToCharArray());
try{ sary.Insert(9, "FOO".ToCharArray()); Console.WriteLine("### INSA_AE ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
}
public void Init()
{
SplitArray <char> chars = new SplitArray <char>(5, 8);
Assert.AreEqual(0, chars.Count);
for (int x = 0; x < 10; x++)
{
MyAssert.Throws <AssertException>(delegate {
chars.GetAt(x);
});
MyAssert.Throws <AssertException>(delegate {
chars.SetAt('!', x);
});
}
}
public void Insert_One()
{
const string InitData = "hogepiyo";
SplitArray <char> sary = new SplitArray <char>(5, 8);
// control-char
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(3, '\0');
Assert.AreEqual("hog\0epiyo", ToString(sary));
// before head
sary.Clear();
sary.Add(InitData.ToCharArray());
MyAssert.Throws <AssertException>(delegate {
sary.Insert(-1, 'G');
});
// head
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(0, 'G');
Assert.AreEqual(9, sary.Count);
Assert.AreEqual("Ghogepiyo", ToString(sary));
// middle
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(4, 'G');
Assert.AreEqual(9, sary.Count);
Assert.AreEqual("hogeGpiyo", ToString(sary));
// end
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(8, 'G');
Assert.AreEqual(9, sary.Count);
Assert.AreEqual("hogepiyoG", ToString(sary));
// after end
sary.Clear();
sary.Add(InitData.ToCharArray());
MyAssert.Throws <AssertException>(delegate {
sary.Insert(9, 'G');
});
}
static void Test_Insert_One()
{
const string InitData = "hogepiyo";
SplitArray <char> sary = new SplitArray <char>(5, 8);
// control-char
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(3, '\0');
TestUtl.AssertEquals("hog\0epiyo", ToString(sary));
// before head
sary.Clear();
sary.Add(InitData.ToCharArray());
try{ sary.Insert(-1, 'G'); Debug.Fail("### INSO_BH ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// head
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(0, 'G');
TestUtl.AssertEquals(9, sary.Count);
TestUtl.AssertEquals("Ghogepiyo", ToString(sary));
// middle
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(4, 'G');
TestUtl.AssertEquals(9, sary.Count);
TestUtl.AssertEquals("hogeGpiyo", ToString(sary));
// end
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Insert(8, 'G');
TestUtl.AssertEquals(9, sary.Count);
TestUtl.AssertEquals("hogepiyoG", ToString(sary));
// after end
sary.Clear();
sary.Add(InitData.ToCharArray());
try{ sary.Insert(9, 'G'); Console.WriteLine("### INSO_AE ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
}
public void GetLineIndexFromCharIndex()
{
SplitArray <int> lhi = new SplitArray <int>(32, 32);
lhi.Add(0);
lhi.Add(32);
lhi.Add(33);
lhi.Add(37);
lhi.Add(38);
lhi.Add(52);
lhi.Add(53);
int i = 0;
for ( ; i < 32; i++)
{
Assert.AreEqual(0, TextUtil.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 33; i++)
{
Assert.AreEqual(1, TextUtil.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 37; i++)
{
Assert.AreEqual(2, TextUtil.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 38; i++)
{
Assert.AreEqual(3, TextUtil.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 52; i++)
{
Assert.AreEqual(4, TextUtil.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 53; i++)
{
Assert.AreEqual(5, TextUtil.GetLineIndexFromCharIndex(lhi, i));
}
Assert.AreEqual(6, TextUtil.GetLineIndexFromCharIndex(lhi, 54));
}
static void Test_GetLineIndexFromCharIndex()
{
SplitArray <int> lhi = new SplitArray <int>(32, 32);
lhi.Add(0);
lhi.Add(32);
lhi.Add(33);
lhi.Add(37);
lhi.Add(38);
lhi.Add(52);
lhi.Add(53);
int i = 0;
for ( ; i < 32; i++)
{
TestUtl.AssertEquals(0, LineLogic.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 33; i++)
{
TestUtl.AssertEquals(1, LineLogic.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 37; i++)
{
TestUtl.AssertEquals(2, LineLogic.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 38; i++)
{
TestUtl.AssertEquals(3, LineLogic.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 52; i++)
{
TestUtl.AssertEquals(4, LineLogic.GetLineIndexFromCharIndex(lhi, i));
}
for ( ; i < 53; i++)
{
TestUtl.AssertEquals(5, LineLogic.GetLineIndexFromCharIndex(lhi, i));
}
TestUtl.AssertEquals(6, LineLogic.GetLineIndexFromCharIndex(lhi, 54));
}
static string MakeLdsText(SplitArray <LineDirtyState> lds)
{
StringBuilder buf = new StringBuilder(32);
for (int i = 0; i < lds.Count; i++)
{
char ch = '#';
switch (lds[i])
{
case LineDirtyState.Clean: ch = 'C'; break;
case LineDirtyState.Dirty: ch = 'D'; break;
case LineDirtyState.Cleaned: ch = 'S'; break;
default: Debug.Fail("invalid LineDirtyState enum value"); break;
}
buf.Append(ch);
}
return(buf.ToString());
}
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);
});
}
}
static void MoveGap(SplitArray <char> sary, int index)
{
sary.Insert(index, new char[] {});
}
static string ToString(SplitArray <char> sary)
{
return(new string( sary.ToArray()));
}
public void LHI_Insert()
{
// 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 TestData1 = "\"keep ot simpler.\"\r\r - Albert Einstein";
const string TestData2 = "it as simple as possible\r\n\nbt\n\rn";
TextBuffer text = new TextBuffer(1, 1);
SplitArray <int> lhi = new SplitArray <int>(1, 1);
SplitArray <LineDirtyState> lds = new SplitArray <LineDirtyState>(1, 1);
lhi.Add(0); lds.Add(LineDirtyState.Clean);
TextUtil.LHI_Insert(lhi, lds, text, TestData1, 0);
text.Add(TestData1.ToCharArray());
Assert.AreEqual("0 19 20", lhi.ToString());
Assert.AreEqual("DDD", MakeLdsText(lds));
for (int i = 0; i < lds.Count; i++)
{
lds[i] = LineDirtyState.Clean;
}
TextUtil.LHI_Insert(lhi, lds, text, TestData2, 6);
text.Insert(6, TestData2.ToCharArray());
Assert.AreEqual("0 32 33 36 37 51 52", lhi.ToString());
Assert.AreEqual("DDDDDCC", MakeLdsText(lds));
for (int i = 0; i < lds.Count; i++)
{
lds[i] = LineDirtyState.Clean;
}
TextUtil.LHI_Insert(lhi, lds, text, "u", 34);
text.Insert(34, "u".ToCharArray());
Assert.AreEqual("0 32 33 37 38 52 53", lhi.ToString());
Assert.AreEqual("CCDCCCC", MakeLdsText(lds));
//--- special care about CR+LF ---
// (1) insertion divides a CR+LF
// (2) inserting text begins with LF creates a new CR+LF at left side of the insertion point
// (3) inserting text ends with CR creates a new CR+LF at right side of the insertion point
//--------------------------------
// (1)+(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_Insert(lhi, lds, text, "\nx", 4);
text.Insert(4, "\nx".ToCharArray());
Assert.AreEqual("0 5 7", lhi.ToString());
Assert.AreEqual("DDC", MakeLdsText(lds));
}
// (1)+(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_Insert(lhi, lds, text, "x\r", 4);
text.Insert(4, "x\r".ToCharArray());
Assert.AreEqual("0 4 7", lhi.ToString());
Assert.AreEqual("DDC", MakeLdsText(lds));
}
// (1)+(2)+(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_Insert(lhi, lds, text, "\n\r", 4);
text.Insert(4, "\n\r".ToCharArray());
Assert.AreEqual("0 5 7", lhi.ToString());
Assert.AreEqual("DDC", MakeLdsText(lds));
}
// (2)
{
text.Clear(); lhi.Clear(); lhi.Add(0); lds.Clear(); lds.Add(LineDirtyState.Clean);
TextUtil.LHI_Insert(lhi, lds, text, "foo\rbar", 0);
text.Add("foo\rbar".ToCharArray());
for (int i = 0; i < lds.Count; i++)
{
lds[i] = LineDirtyState.Clean;
}
TextUtil.LHI_Insert(lhi, lds, text, "\nx", 4);
text.Insert(4, "\nx".ToCharArray());
Assert.AreEqual("0 5", 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\nbar", 0);
text.Add("foo\nbar".ToCharArray());
for (int i = 0; i < lds.Count; i++)
{
lds[i] = LineDirtyState.Clean;
}
TextUtil.LHI_Insert(lhi, lds, text, "x\r", 3);
text.Insert(3, "x\r".ToCharArray());
Assert.AreEqual("0 6", lhi.ToString());
Assert.AreEqual("DC", MakeLdsText(lds));
}
}
static void MakeTestData(out TextBuffer text, out SplitArray <int> lhi)
{
SplitArray <LineDirtyState> lds = new SplitArray <LineDirtyState>(8);
MakeTestData(out text, out lhi, out lds);
}
static void Test_Replace()
{
const string InitData = "hogepiyo";
SplitArray <char> sary = new SplitArray <char>(5, 8);
// replace position
{
// before head
sary.Clear();
sary.Add(InitData.ToCharArray());
try{ sary.Replace(-1, "000".ToCharArray(), 0, 2); Console.WriteLine("### REP_P_BH ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// head
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Replace(0, "000".ToCharArray(), 0, 2);
TestUtl.AssertEquals("00gepiyo", ToString(sary));
// middle
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Replace(4, "000".ToCharArray(), 0, 2);
TestUtl.AssertEquals("hoge00yo", ToString(sary));
// end
sary.Clear();
sary.Add(InitData.ToCharArray());
sary.Replace(6, "000".ToCharArray(), 0, 2);
TestUtl.AssertEquals("hogepi00", ToString(sary));
// after end
sary.Clear();
sary.Add(InitData.ToCharArray());
try{ sary.Replace(7, "000".ToCharArray(), 0, 2); Console.WriteLine("### REP_P_AE1 ##"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
try{ sary.Replace(8, "000".ToCharArray(), 0, 2); Console.WriteLine("### REP_P_AE2 ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
}
// value array
{
// giving null
try{ sary.Replace(0, null, 0, 1); Console.WriteLine("### REP_A_NULL ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// empty array
sary.Replace(0, "".ToCharArray(), 0, 0);
TestUtl.AssertEquals("hogepiyo", ToString(sary));
// empty range
sary.Replace(0, "000".ToCharArray(), 0, 0);
TestUtl.AssertEquals("hogepiyo", ToString(sary));
// invalid range (reversed)
try{ sary.Replace(0, "000".ToCharArray(), 1, 0); Console.WriteLine("### REP_A_REV ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// invalid range (before head)
try{ sary.Replace(0, "000".ToCharArray(), -1, 0); Console.WriteLine("### REP_A_BH ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
// invalid range (after head)
try{ sary.Replace(0, "000".ToCharArray(), 3, 4); Console.WriteLine("### REPEP_A_AE ###"); }
catch (Exception ex) { TestUtl.AssertType <AssertException>(ex); }
}
}
