private void Test1Sentence(BreakIterator bi, String text)
{
int start = bi.Text.BeginIndex;
assertEquals(start, bi.First());
int current = bi.Current;
assertEquals(bi.Text.EndIndex, bi.Next());
int end = bi.Current - start;
assertEquals(text, text.Substring(current - start, end - start));
assertEquals(text.Length, bi.Last() - start);
end = bi.Current;
bi.Previous();
assertEquals(BreakIterator.Done, bi.Previous());
int previous = bi.Current;
assertEquals(text, text.Substring(previous - start, end - start));
assertEquals(start, bi.Current);
assertEquals(BreakIterator.Done, bi.Following(bi.Last() / 2 + start));
assertEquals(BreakIterator.Done, bi.Preceding(bi.Last() / 2 + start));
assertEquals(start, bi.First());
assertEquals(BreakIterator.Done, bi.Next(13));
assertEquals(BreakIterator.Done, bi.Next(-8));
}
/** Asserts that two breakiterators break the text the same way */
public void assertSameBreaks(CharacterIterator one, CharacterIterator two, BreakIterator expected, BreakIterator actual)
{
expected.SetText(one);
actual.SetText(two);
assertEquals(expected.Current, actual.Current);
// next()
int v = expected.Current;
while (v != BreakIterator.DONE)
{
assertEquals(v = expected.Next(), actual.Next());
assertEquals(expected.Current, actual.Current);
}
// first()
assertEquals(expected.First(), actual.First());
assertEquals(expected.Current, actual.Current);
// last()
assertEquals(expected.Last(), actual.Last());
assertEquals(expected.Current, actual.Current);
// previous()
v = expected.Current;
while (v != BreakIterator.DONE)
{
assertEquals(v = expected.Previous(), actual.Previous());
assertEquals(expected.Current, actual.Current);
}
// following()
for (int i = one.BeginIndex; i <= one.EndIndex; i++)
{
expected.First();
actual.First();
assertEquals(expected.Following(i), actual.Following(i));
assertEquals(expected.Current, actual.Current);
}
// preceding()
for (int i = one.BeginIndex; i <= one.EndIndex; i++)
{
expected.Last();
actual.Last();
assertEquals(expected.Preceding(i), actual.Preceding(i));
assertEquals(expected.Current, actual.Current);
}
}
private List <String> _testLastAndPrevious(BreakIterator bi, String text)
{
int p = bi.Last();
int lastP = p;
List <String> result = new List <String>();
if (p != text.Length)
{
Errln("last() returned " + p + " instead of " + text.Length);
}
while (p != BreakIterator.Done)
{
p = bi.Previous();
if (p != BreakIterator.Done)
{
if (p >= lastP)
{
Errln("previous() failed to move backward: previous() on position "
+ lastP + " yielded " + p);
}
result.Insert(0, text.Substring(p, lastP - p)); // ICU4N: Corrected 2nd substring parameter
}
else
{
if (lastP != 0)
{
Errln("previous() returned DONE prematurely: offset was "
+ lastP + " instead of 0");
}
}
lastP = p;
}
return(result);
}
public virtual int FindStartOffset(StringBuilder buffer, int start)
{
// avoid illegal start offset
if (start > buffer.Length || start < 1) return start;
bi.SetText(buffer.ToString(0, start - 0));
bi.Last();
return bi.Previous();
}
private void Test0Sentences(BreakIterator bi)
{
assertEquals(0, bi.Current);
assertEquals(0, bi.First());
assertEquals(BreakIterator.Done, bi.Next());
assertEquals(0, bi.Last());
assertEquals(BreakIterator.Done, bi.Previous());
assertEquals(BreakIterator.Done, bi.Following(0));
assertEquals(BreakIterator.Done, bi.Preceding(0));
assertEquals(0, bi.First());
assertEquals(BreakIterator.Done, bi.Next(13));
assertEquals(BreakIterator.Done, bi.Next(-8));
}
private void Do3SentenceTest(BreakIterator bi) // LUCENENET NOTE: Refactored a bit because Substring in .NET requires some light math to match Java
{
assertEquals(0, bi.Current);
assertEquals(0, bi.First());
int current = bi.Current;
assertEquals(SENTENCES[0], TEXT.Substring(current, bi.Next() - current)); // LUCNENENET: Corrected 2nd parameter
current = bi.Current;
assertEquals(SENTENCES[1], TEXT.Substring(current, bi.Next() - current)); // LUCNENENET: Corrected 2nd parameter
current = bi.Current;
assertEquals(bi.Text.EndIndex, bi.Next());
int next = bi.Current;
assertEquals(SENTENCES[2], TEXT.Substring(current, next - current)); // LUCNENENET: Corrected 2nd parameter
assertEquals(BreakIterator.Done, bi.Next());
assertEquals(TEXT.Length, bi.Last());
int end = bi.Current;
int prev = bi.Previous();
assertEquals(SENTENCES[2], TEXT.Substring(prev, end - prev)); // LUCNENENET: Corrected 2nd parameter
end = bi.Current;
prev = bi.Previous();
assertEquals(SENTENCES[1], TEXT.Substring(prev, end - prev)); // LUCNENENET: Corrected 2nd parameter
end = bi.Current;
prev = bi.Previous();
assertEquals(SENTENCES[0], TEXT.Substring(prev, end - prev)); // LUCNENENET: Corrected 2nd parameter
assertEquals(BreakIterator.Done, bi.Previous());
assertEquals(0, bi.Current);
assertEquals(59, bi.Following(39));
assertEquals(59, bi.Following(31));
assertEquals(31, bi.Following(30));
assertEquals(0, bi.Preceding(57));
assertEquals(0, bi.Preceding(58));
assertEquals(31, bi.Preceding(59));
assertEquals(0, bi.First());
assertEquals(59, bi.Next(2));
assertEquals(0, bi.Next(-2));
}
public void TestLineIteration()
{
BreakIterator bi = GetLineInstance(System.Globalization.CultureInfo.InvariantCulture);
// Test empty
Assert.AreEqual(0, bi.Current);
Assert.AreEqual(BreakIterator.Done, bi.Next());
Assert.AreEqual(0, bi.Current);
bi.SetText(LINE_TEXT);
// Ensure position starts at 0 when initialized
Assert.AreEqual(0, bi.Current);
// Check first boundary (Apache\t^Lucene) - Ensure we break on \t
Assert.AreEqual(7, bi.Next());
// Ensure Current returns the most recent boundary
Assert.AreEqual(7, bi.Current);
// Check next boundary (Lucene^(TM))
Assert.AreEqual(13, bi.Next());
// Ensure Current returns the most recent boundary
Assert.AreEqual(13, bi.Current);
// Check next boundary (Lucene(TM) ^is a)
Assert.AreEqual(18, bi.Next());
// Ensure Current returns the most recent boundary
Assert.AreEqual(18, bi.Current);
// Move to start of high-performance
bi.Next();
bi.Next();
// Check next boundary (high-\n^performance)
Assert.AreEqual(29, bi.Next());
// Check last boundary (in Java.^)
Assert.AreEqual(108, bi.Last());
// Check move past last boundary
Assert.AreEqual(BreakIterator.Done, bi.Next());
// Ensure we are still at last boundary
Assert.AreEqual(108, bi.Current);
// Check MovePrevious
Assert.AreEqual(103, bi.Previous());
// Ensure we get the same value for Current as the last move
Assert.AreEqual(103, bi.Current);
// Check MoveFirst
Assert.AreEqual(0, bi.First());
// Ensure we get the same value for Current as the last move
Assert.AreEqual(0, bi.Current);
// Check moving beyond first boundary
Assert.AreEqual(BreakIterator.Done, bi.Previous());
// Ensure we are still at first boundary
Assert.AreEqual(0, bi.Current);
// Check MoveLast()
Assert.AreEqual(108, bi.Last());
}
public void TestWordIteration()
{
BreakIterator bi = GetWordInstance(System.Globalization.CultureInfo.InvariantCulture);
bi.SetText("");
// Test empty
Assert.AreEqual(0, bi.Current);
Assert.AreEqual(BreakIterator.Done, bi.Next());
Assert.AreEqual(0, bi.Current);
bi.SetText(TEXT);
// Ensure position starts at 0 when initialized
Assert.AreEqual(0, bi.Current);
// Check first boundary (Apache^)
Assert.AreEqual(6, bi.Next());
// Ensure Current returns the last boundary iterated to
Assert.AreEqual(6, bi.Current);
// Check second boundary (^Lucene)
Assert.AreEqual(7, bi.Next());
// Ensure Current returns the last boundary iterated to
Assert.AreEqual(7, bi.Current);
// Check third boundary (Lucene^)
Assert.AreEqual(13, bi.Next());
// Ensure Current returns the last boundary iterated to
Assert.AreEqual(13, bi.Current);
// Check fourth boundary (^TM)
Assert.AreEqual(14, bi.Next());
// Check fifth boundary (TM^)
Assert.AreEqual(16, bi.Next());
// Check sixth boundary (TM)^
Assert.AreEqual(17, bi.Next());
// Check seventh boundary (^is)
Assert.AreEqual(18, bi.Next());
// Move to (^high-performance)
bi.Next();
bi.Next();
bi.Next();
// Check next boundary (^high-performance)
Assert.AreEqual(23, bi.Next());
// Ensure we don't break on hyphen (high-performance^)
Assert.AreEqual(39, bi.Next());
// Check MoveLast()
Assert.AreEqual(107, bi.Last());
// Check going past last boundary
Assert.AreEqual(BreakIterator.Done, bi.Next());
// Check we are still at last boundary
Assert.AreEqual(107, bi.Current);
// Check MoveFirst()
Assert.AreEqual(0, bi.First());
// Check going past first boundary
Assert.AreEqual(BreakIterator.Done, bi.Previous());
// Check we are still at first boundary
Assert.AreEqual(0, bi.Current);
}
public void TestSentenceIteration()
{
BreakIterator bi = GetSentenceInstance(System.Globalization.CultureInfo.InvariantCulture);
bi.SetText("");
// Test empty
Assert.AreEqual(0, bi.Current);
Assert.AreEqual(BreakIterator.Done, bi.Next());
Assert.AreEqual(0, bi.Current);
bi.SetText(SENTENCE_TEXT);
// Ensure position starts at 0 when initialized
Assert.AreEqual(0, bi.Current);
// Check first boundary (in Java.^) - Ensure we don't break on \n
Assert.AreEqual(108, bi.Next());
// Ensure Current returns the most recent boundary
Assert.AreEqual(108, bi.Current);
// Check next boundary (especially cross-platform.^)
Assert.AreEqual(221, bi.Next());
// Check next boundary (free download.^)
Assert.AreEqual(290, bi.Next());
// Check next boundary (things easy.^)
Assert.AreEqual(324, bi.Next());
// Check next boundary (is powerful.^)
Assert.AreEqual(344, bi.Next());
// Check next boundary (is exciting.^)
Assert.AreEqual(364, bi.Next());
// Check next boundary (is cool.^)
Assert.AreEqual(380, bi.Next());
// Check last boundary (Lucene now?^)
Assert.AreEqual(400, bi.Next());
// Check move past last boundary
Assert.AreEqual(BreakIterator.Done, bi.Next());
// Ensure we are still at last boundary
Assert.AreEqual(400, bi.Current);
// Check MovePrevious
Assert.AreEqual(380, bi.Previous());
// Ensure we get the same value for Current as the last move
Assert.AreEqual(380, bi.Current);
// Check MoveFirst
Assert.AreEqual(0, bi.First());
// Ensure we get the same value for Current as the last move
Assert.AreEqual(0, bi.Current);
// Check moving beyond first boundary
Assert.AreEqual(BreakIterator.Done, bi.Previous());
// Ensure we are still at first boundary
Assert.AreEqual(0, bi.Current);
// Check MoveLast()
Assert.AreEqual(400, bi.Last());
}
public override int Last()
{
// Don't suppress a break opportunity at the end of text.
return(@delegate.Last());
}
/// <summary>
/// Returns the position at the end of the next layout. Does NOT
/// update the current position of this <code>LineBreakMeasurer</code>.
/// </summary>
/// <param name="wrappingWidth"> the maximum visible advance permitted for
/// the text in the next layout </param>
/// <param name="offsetLimit"> the first character that can not be included
/// in the next layout, even if the text after the limit would fit
/// within the wrapping width; <code>offsetLimit</code> must be
/// greater than the current position </param>
/// <param name="requireNextWord"> if <code>true</code>, the current position
/// that is returned if the entire next word does not fit within
/// <code>wrappingWidth</code>; if <code>false</code>, the offset
/// returned is at least one greater than the current position </param>
/// <returns> an offset in the text representing the limit of the
/// next <code>TextLayout</code> </returns>
public int NextOffset(float wrappingWidth, int offsetLimit, bool requireNextWord)
{
int nextOffset = Pos;
if (Pos < Limit)
{
if (offsetLimit <= Pos)
{
throw new IllegalArgumentException("offsetLimit must be after current position");
}
int charAtMaxAdvance = Measurer.GetLineBreakIndex(Pos, wrappingWidth);
if (charAtMaxAdvance == Limit)
{
nextOffset = Limit;
}
else if (char.IsWhiteSpace(Measurer.Chars[charAtMaxAdvance - Start]))
{
nextOffset = BreakIter.Following(charAtMaxAdvance);
}
else
{
// Break is in a word; back up to previous break.
// NOTE: I think that breakIter.preceding(limit) should be
// equivalent to breakIter.last(), breakIter.previous() but
// the authors of BreakIterator thought otherwise...
// If they were equivalent then the first branch would be
// unnecessary.
int testPos = charAtMaxAdvance + 1;
if (testPos == Limit)
{
BreakIter.Last();
nextOffset = BreakIter.Previous();
}
else
{
nextOffset = BreakIter.Preceding(testPos);
}
if (nextOffset <= Pos)
{
// first word doesn't fit on line
if (requireNextWord)
{
nextOffset = Pos;
}
else
{
nextOffset = System.Math.Max(Pos + 1, charAtMaxAdvance);
}
}
}
}
if (nextOffset > offsetLimit)
{
nextOffset = offsetLimit;
}
return(nextOffset);
}
