Naja, das hatte ich oben ja aber auch gleich geschrieben: “In einen normalen String”
Ich habe mal versucht herumzurefakturieren, aber richtig schön bekomme ich das ganze gerade nicht. Nun sieht es so aus und ich weiß nichtmal, ob das schöner ist:
/** Systemunabhängiger Zeilenumbruch. */
private static final String LINE_BREAK = System.getProperty("line.separator");
/** Gibt an, ob Debugginginformationen ausgegeben werden sollen. */
private static final boolean DEBUG = false;
/** Gewünschte Zeilenlänge. */
private final int lineLength;
/** Ein Textteil, der gerade umgebrochen werden soll. */
private String text;
/** Ein StringBuilder, in dem Textteile und Umbrüche gesammelt werden. */
private StringBuilder builder;
/** Aktueller Index im gerade betrachteten Textteil. */
private int index;
/** Länge des gerade betrachteten Textteils. */
private int textLength;
/**
* Konstruktor.
*
* @param lineLength
* Gewünschte Zeilenlänge.
*/
public TextBreaker(int lineLength) {
this.lineLength = lineLength;
}
/**
* Versieht einen langen Text mit Zeilenumbrüchen, so dass die Zeilen - so überhaupt
* Leerzeichen vorhanden sind - höchstens lineLength Zeichen lang sind. Hierbei wird dieser
* zuvor an schon vorhandenen Umbrüchen umgebrochen und nur die Teile dazwischen behandelt.
*
* @param text
* Gegebener Text.
* @return Umgebrochener Text.
*/
public String addLineBreaks(String text) {
String[] parts = text.trim().split("(" + LINE_BREAK + "|
|
)", -1);
StringBuilder builder = new StringBuilder();
for (String part : parts) {
builder.append(addLineBreaksToPart(part));
builder.append(LINE_BREAK);
}
builder.replace(builder.length() - LINE_BREAK.length(), builder.length(), "");
return builder.toString();
}
/**
* Versieht einen langen Text mit Zeilenumbrüchen, so dass die Zeilen - so überhaupt
* Leerzeichen vorhanden sind, höchstens lineLength Zeichen lang sind.
*
* Hier weiß man, dass keine Umbrüche im Text vorkommen.
*
* @param text
* Gegebener Text.
* @return Umgebrochener Text.
*/
private String addLineBreaksToPart(String text) {
if (text.length() <= lineLength) {
return text;
}
else {
return addLineBreaksToLongPart(text);
}
}
/**
* Versieht einen langen Text mit Zeilenumbrüchen, so dass die Zeilen - so überhaupt
* Leerzeichen vorhanden sind, höchstens lineLength Zeichen lang sind.
*
* Hier weiß man, dass keine Umbrüche im Text vorkommen und dass der Textteil zu lang ist.
*
* @param text
* Gegebener Text.
* @return Umgebrochener Text.
*/
private String addLineBreaksToLongPart(String text) {
this.text = text;
builder = new StringBuilder();
index = 0;
textLength = text.length();
workOnText();
if (builder.toString().endsWith(LINE_BREAK)) {
builder.replace(builder.length() - LINE_BREAK.length(), builder.length(), "");
}
return builder.toString();
}
private void workOnText() {
while (index < textLength - 1) {
debug("Schleifenstart: index = " + index + ", restlicher Text: "
+ text.substring(index));
/*
* Falls der Rest des Textes kurz genug ist, wird er hinzugefügt und die Schleife
* verlassen:
*/
if (textLength - index <= lineLength) {
debug("Rest kurz genug.");
append(text.substring(index, textLength));
return;
}
/* Es wird der Index des nächsten Leerzeichens berechnet: */
int indexOfSpace = text.indexOf(' ', index);
debug("indexOfSpace = " + indexOfSpace);
/*
* Falls es kein nächstes Leerzeichen gibt, wird ebenfalls der Rest hinzugefügt und die
* Schleife verlassen:
*/
if (-1 == indexOfSpace) {
debug("Kein Leerzeichen gefunden.");
append(text.substring(index, textLength));
return;
}
/* Falls das nächste Leerzeichen schon zu weit weg ist, wird dieser Teil eingefügt: */
if (indexOfSpace - index > lineLength) {
append(text.substring(index, indexOfSpace));
index = indexOfSpace + 1;
continue;
}
/* Es wird der Index des übernächsten Leerzeichens berechnet: */
int indexOfNextSpace = text.indexOf(' ', indexOfSpace+1);
debug("indexOfNextSpace = " + indexOfNextSpace);
/*
* Falls es kein übernächstes Leerzeichen gibt, wird der Teil zwischen den Leerzeichen,
* ein Zeilenumbruch sowie der Rest hinzugefügt und die Schleife verlassen:
*/
if (-1 == indexOfNextSpace) {
debug("Kein nächstes Leerzeichen gefunden.");
append(text.substring(index, indexOfSpace));
append(text.substring(indexOfSpace + 1));
/*
* Der Text endet nicht auf ein Leerzeichen, da wir vorhin text.trim() ausgeführt
* haben. Deshalb müssen nach indexOfSpace noch Zeichen im Text sein.
* Daher kann text.substring(indexOfSpace + 1) keine Probleme machen.
*/
/*
* Ich traue dem nicht, weil nicht der Part getrimmt wird, sondern nur der
* Originalstring. Aber ich finde kein Gegenbeispiel...
*/
return;
}
/* Wir suchen solange das nächste Leerzeichen, bis der Text zu lang würde: */
indexOfSpace = searchForSpaces(indexOfSpace, indexOfNextSpace);
if (-2 == indexOfSpace) {
continue;
}
append(text.substring(index, indexOfSpace));
index = indexOfSpace + 1;
}
}
/**
* Sucht so lange nach dem nächste, bis der Text zu lang würde.
*
* @param indexOfSpaceStart
* Index des ersten Leerzeichens ab dem Index.
* @param indexOfNextSpaceStart
* Index des zweiten Leerzeichens ab dem Index.
* @return Index des Leerzeichens, an dem getrennt werden soll, oder -2 als Zeichen dafür, dass
* schon angefügt wurde und die äußere Schleife weiterlaufen soll.
*/
private int searchForSpaces(int indexOfSpaceStart, int indexOfNextSpaceStart) {
int indexOfSpace = indexOfSpaceStart;
int indexOfNextSpace = indexOfNextSpaceStart;
while (indexOfNextSpace <= index + lineLength) {
int rememberIndexOfNextSpace = indexOfNextSpace;
indexOfNextSpace = text.indexOf(' ', indexOfSpace+1);
debug("indexOfSpace = " + indexOfSpace + ", indexOfNextSpace = " + indexOfNextSpace
+ ", rememberIndexOfNextSpace = " + rememberIndexOfNextSpace);
/*
* Falls es kein x-nächstes Leerzeichen gibt, wird der Teil zwischen den
* Leerzeichen und ein Zeilenumbruch die zum nächsten Schleifendurchlauf
* gewechselt:
*/
if (-1 == indexOfNextSpace) {
debug("Kein nächstes Leerzeichen in innerer Whileschleife gefunden.");
append(text.substring(index, indexOfSpace));
index = indexOfSpace + 1;
return -2;
}
else {
indexOfSpace = rememberIndexOfNextSpace;
}
}
return indexOfSpace;
}
/**
* Fügt einen Textteil gefolgt von einem Zeilenumbruch zum StringBuilder hinzu.
*
* @param textPart
* Anzufügender Textteil.
*/
private void append(final String textPart) {
debug("Füge hinzu: " + textPart);
builder.append(textPart);
debug("Füge hinzu: Zeilenumbruch");
builder.append(LINE_BREAK);
}
/** Falls das Debugging aktiv ist, wird eine Ausgabe vorgenommen. */
private static void debug(final String text) {
if (DEBUG) {
System.out.println(text);
}
}
}
Mit den Tests
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class TextBreakerTest {
@Test
public void breakNoBreak() {
String text = "Mal sehen was so passiert!";
String expected = text;
int lineLength = 80;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakNoBreakRemoveTrailingBlank() {
String text = "Mal sehen was so passiert! ";
String expected = "Mal sehen was so passiert!";
int lineLength = 80;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAddOneBreak() {
String text = "Mal sehen was so passiert! ";
String expected = "Mal sehen was" + LINE_BREAK + "so passiert!";
int lineLength = 15;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAddFourBreaks() {
String text = "Mal sehen was so passiert! ";
String expected = "Mal" + LINE_BREAK
+ "sehen" + LINE_BREAK
+ "was" + LINE_BREAK
+ "so" + LINE_BREAK
+ "passiert!";
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAddBreaksWithLongParts() {
String text = "Mal sehen was so AUSSERGEWÖHNLICHLANGES passiert! ";
String expected = "Mal" + LINE_BREAK
+ "sehen" + LINE_BREAK
+ "was" + LINE_BREAK
+ "so" + LINE_BREAK
+ "AUSSERGEWÖHNLICHLANGES" + LINE_BREAK
+ "passiert!";
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAddNoBreaksAtUnderscores() {
String text = "Mal_sehen_was_so_AUSSERGEWÖHNLICHLANGES_passiert!";
String expected = text;
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakBreakAtExaktTextPartLengths() {
String text = "ab cd ef";
String expected = "ab" + LINE_BREAK + "cd" + LINE_BREAK + "ef";
int lineLength = 2;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakBreakAtSmallerLineLengthThanTextPartLength() {
String text = "ab cd ef";
String expected = "ab" + LINE_BREAK + "cd" + LINE_BREAK + "ef";
int lineLength = 1;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakBreakAtLineLengthEqualsTextPartLengthAndSpace() {
String text = "ab cd ef";
String expected = "ab" + LINE_BREAK + "cd" + LINE_BREAK + "ef";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakBeforeLineIsTooLong() {
String text = "ab cd ef";
String expected = "ab" + LINE_BREAK + "cd" + LINE_BREAK + "ef";
int lineLength = 4;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAfterTwoParts() {
String text = "ab cd ef";
String expected = "ab cd" + LINE_BREAK + "ef";
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakSmallParts() {
String text = "ab cd ef gh ij kl mn op qr";
String expected = "ab cd" + LINE_BREAK + "ef gh" + LINE_BREAK + "ij kl"
+ LINE_BREAK + "mn op" + LINE_BREAK + "qr";
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakHandleExistingBreakes() {
String text = "Mal
sehen
was so AUSSERGEWÖHNLICHLANGES passiert! ";
String expected = "Mal" + LINE_BREAK
+ "sehen" + LINE_BREAK
+ "was so" + LINE_BREAK
+ "AUSSERGEWÖHNLICHLANGES" + LINE_BREAK
+ "passiert!";
int lineLength = 10;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces() {
String text = "ab" + LINE_BREAK + " " + LINE_BREAK + "cd";
String expected = "ab" + LINE_BREAK + " " + LINE_BREAK + "cd";
int lineLength = 2;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces2() {
String text = "ab ab " + LINE_BREAK + " " + LINE_BREAK + "cd";
String expected = "ab" + LINE_BREAK + "ab " + LINE_BREAK + " " + LINE_BREAK + "cd";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces3() {
String text = "ab ab" + LINE_BREAK + " " + LINE_BREAK + "cd";
String expected = "ab" + LINE_BREAK + "ab" + LINE_BREAK + " " + LINE_BREAK + "cd";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces4() {
String text = "ab x" + LINE_BREAK + " " + LINE_BREAK + "cd";
String expected = "ab" + LINE_BREAK + "x" + LINE_BREAK + " " + LINE_BREAK + "cd";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces5() {
String text = "ab " + LINE_BREAK;
String expected = "ab";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
}
*** Edit ***
Wie oft, wenn einem etwas gar nicht gefällt, sollte man den Algorithmus ändern. Die neue Version arbeitet ganz anders und gefällt mir deutlich besser. Dank Rekursion und Entheddern von Aufteilen und StringBuilder wird das ganze wesentlich übersichtlicher:
import java.util.Arrays;
import java.util.List;
public class TextBreaker {
/** Systemunabhängiger Zeilenumbruch. */
static final String LINE_BREAK = System.getProperty("line.separator");
/** Gewünschte Zeilenlänge. */
private final int lineLength;
/**
* Konstruktor.
*
* @param lineLength
* Gewünschte Zeilenlänge.
*/
public TextBreaker(int lineLength) {
this.lineLength = lineLength;
}
/**
* Versieht einen langen Text an Leerzeichen mit Zeilenumbrüchen, so dass die Zeilen höchstens
* lineLength Zeichen lang sind, - falls ausreichend Leerzeichen dafür vorhanden sind.
*
* Hierbei wird der Text zuvor an schon vorhandenen Umbrüchen umgebrochen.
*
* @param text
* Gegebener Text.
* @return Umgebrochener Text.
*/
public String addLineBreaks(String text) {
List<String> brokenParts = new ArrayList<>();
for (String part : breakTextBetweenExistingLineBreaks(text)) {
brokenParts.addAll(breakAtSpaces(part));
}
return generateOutputString(brokenParts);
}
private List<String> breakTextBetweenExistingLineBreaks(String text) {
return Arrays.asList(text.split("(" + LINE_BREAK + "|
|
)", -1));
}
private String generateOutputString(List<String> brokenParts) {
StringBuilder builder = new StringBuilder();
boolean first = true;
for (String brokenPart : brokenParts) {
if (first) {
first = false;
}
else {
builder.append(LINE_BREAK);
}
builder.append(brokenPart);
}
return builder.toString();
}
private List<String> breakAtSpaces(String part) {
List<String> brokenParts = new ArrayList<>();
if (textIsSmallEnough(part) || textHasNoSpaces(part)) {
brokenParts.add(part);
}
else {
brokenParts.addAll(breakAtBestSpace(part));
}
return brokenParts;
}
private List<String> breakAtBestSpace(String part) {
List<String> brokenParts = new ArrayList<>();
int devidingIndex;
int firstSpaceIndex = part.indexOf(" ");
if (textIsSmallEnoughAtSpaceIndex(firstSpaceIndex)) {
int lastGoodSpaceIndex = firstSpaceIndex;
int aSpaceIndex = part.indexOf(" ", lastGoodSpaceIndex + 1);
while (aSpaceIndex > -1 && textIsSmallEnoughAtSpaceIndex(aSpaceIndex)) {
lastGoodSpaceIndex = aSpaceIndex;
aSpaceIndex = part.indexOf(" ", lastGoodSpaceIndex + 1);
}
devidingIndex = lastGoodSpaceIndex;
}
else {
devidingIndex = firstSpaceIndex;
}
String partBeforeSpace = part.substring(0, devidingIndex);
String partAfterSpace = part.substring(devidingIndex + 1);
brokenParts.add(partBeforeSpace);
brokenParts.addAll(breakAtSpaces(partAfterSpace));
return brokenParts;
}
private boolean textIsSmallEnough(String part) {
return part.length() <= lineLength;
}
private boolean textIsSmallEnoughAtSpaceIndex(int spaceIndex) {
return spaceIndex <= lineLength;
/*
* Nicht
* spaceIndex -1 <= lineLength
* weil das Leerzeichen ja nicht mitzählt!
*/
}
private boolean textHasNoSpaces(String text) {
return !text.contains(" ");
}
}
Mit den Tests
import static ...paket....TextBreaker.LINE_BREAK;
import org.junit.Test;
public class TextBreakerTest {
@Test
public void breakNoBreak() {
String text = "Mal sehen was so passiert!";
String expected = text;
int lineLength = 80;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakNoBreakNotRemovingTrailingBlank() {
String text = "Mal sehen was so passiert! ";
String expected = "Mal sehen was so passiert! ";
int lineLength = 80;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAddOneBreak() {
String text = "Mal sehen was so passiert!";
String expected = "Mal sehen was" + LINE_BREAK + "so passiert!";
int lineLength = 15;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAddFourBreaks() {
String text = "Mal sehen was so passiert!";
String expected = "Mal" + LINE_BREAK
+ "sehen" + LINE_BREAK
+ "was" + LINE_BREAK
+ "so" + LINE_BREAK
+ "passiert!";
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAddBreaksWithLongParts() {
String text = "Mal sehen was so AUSSERGEWÖHNLICHLANGES passiert!";
String expected = "Mal" + LINE_BREAK
+ "sehen" + LINE_BREAK
+ "was" + LINE_BREAK
+ "so" + LINE_BREAK
+ "AUSSERGEWÖHNLICHLANGES" + LINE_BREAK
+ "passiert!";
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAddNoBreaksAtUnderscores() {
String text = "Mal_sehen_was_so_AUSSERGEWÖHNLICHLANGES_passiert!";
String expected = text;
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakBreakAtExaktTextPartLengths() {
String text = "ab cd ef";
String expected = "ab" + LINE_BREAK + "cd" + LINE_BREAK + "ef";
int lineLength = 2;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakBreakAtSmallerLineLengthThanTextPartLength() {
String text = "ab cd ef";
String expected = "ab" + LINE_BREAK + "cd" + LINE_BREAK + "ef";
int lineLength = 1;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakBreakAtLineLengthEqualsTextPartLengthAndSpace() {
String text = "ab cd ef";
String expected = "ab" + LINE_BREAK + "cd" + LINE_BREAK + "ef";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakBeforeLineIsTooLong() {
String text = "ab cd ef";
String expected = "ab" + LINE_BREAK + "cd" + LINE_BREAK + "ef";
int lineLength = 4;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakAfterTwoParts() {
String text = "ab cd ef";
String expected = "ab cd" + LINE_BREAK + "ef";
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakSmallParts() {
String text = "ab cd ef gh ij kl mn op qr";
String expected = "ab cd" + LINE_BREAK + "ef gh" + LINE_BREAK + "ij kl"
+ LINE_BREAK + "mn op" + LINE_BREAK + "qr";
int lineLength = 5;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakHandleExistingBreakes() {
String text = "Mal
sehen
was so AUSSERGEWÖHNLICHLANGES passiert!";
String expected = "Mal" + LINE_BREAK
+ "sehen" + LINE_BREAK
+ "was so" + LINE_BREAK
+ "AUSSERGEWÖHNLICHLANGES" + LINE_BREAK
+ "passiert!";
int lineLength = 10;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces() {
String text = "ab" + LINE_BREAK + " " + LINE_BREAK + "cd";
String expected = "ab" + LINE_BREAK + " " + LINE_BREAK + "cd";
int lineLength = 2;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces2() {
String text = "ab ab " + LINE_BREAK + " " + LINE_BREAK + "cd";
String expected = "ab" + LINE_BREAK + "ab " + LINE_BREAK + " " + LINE_BREAK + "cd";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces3() {
String text = "ab ab" + LINE_BREAK + " " + LINE_BREAK + "cd";
String expected = "ab" + LINE_BREAK + "ab" + LINE_BREAK + " " + LINE_BREAK + "cd";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces4() {
String text = "ab x" + LINE_BREAK + " " + LINE_BREAK + "cd";
String expected = "ab" + LINE_BREAK + "x" + LINE_BREAK + " " + LINE_BREAK + "cd";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void breakExistingBreaksWithSpaces5() {
String text = "ab " + LINE_BREAK;
String expected = "ab " + LINE_BREAK;
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void multipleSpaces1() {
String text = "ab cd";
String expected = "ab " + LINE_BREAK + " cd";
int lineLength = 3;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
@Test
public void multipleSpaces2() {
String text = "ab cd";
String expected = "ab" + LINE_BREAK + " "+ LINE_BREAK + "cd";
int lineLength = 2;
TextBreaker breaker = new TextBreaker(lineLength);
String actual = breaker.addLineBreaks(text);
assertEquals(expected, actual);
}
}
