From c29cfb1e58bc459b235fbc9f9ff4793b1c1dac8b Mon Sep 17 00:00:00 2001 From: tmrd993 Date: Fri, 4 Sep 2020 22:34:32 +0200 Subject: [PATCH 1/7] Add multi-sentence title formatting to sentence case and title case --- ...ssion-to-split-multiple-sentence-titles.md | 25 ++++++++++++++++ .../casechanger/SentenceCaseFormatter.java | 15 ++++++++-- .../casechanger/TitleCaseFormatter.java | 28 ++++++++++------- .../org/jabref/model/strings/StringUtil.java | 8 +++++ .../SentenceCaseFormatterTest.java | 30 +++++++++++++++++++ .../casechanger/TitleCaseFormatterTest.java | 12 ++++++++ 6 files changed, 105 insertions(+), 13 deletions(-) create mode 100644 docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md diff --git a/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md b/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md new file mode 100644 index 00000000000..2722c7d5a1f --- /dev/null +++ b/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md @@ -0,0 +1,25 @@ +# Use regular expression to split multiple-sentence titles + +## Context and Problem Statement + +Some entry titles are composed of multiple sentences, for example: "Whose Music? A Sociology of Musical Language", therefore, it is necessary to first split the title into sentences and process them individually to ensure proper formatting using 'Sentence Case' or 'Title Case' + +## Considered Options + +* [Regular expression](https://docs.oracle.com/javase/tutorial/essential/regex/) +* [OpenNLP](https://opennlp.apache.org/) +* [ICU4J](http://site.icu-project.org/home) - + +## Decision Outcome + +Chosen option: "Regular expression", because we can use Java internal classes (Pattern, Matcher) instead of adding additional dependencies + +### Positive Consequences + +* Less dependencies on third party libraries +* Smaller project size (ICU4J is very large) +* No need for model data (OpenNLP is a machine learning based toolkit and needs a trained model to work properly) + +### Negative Consequences + +* Regular expressions can never cover every case, therefore, splitting may not be accurate for every title \ No newline at end of file diff --git a/src/main/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatter.java b/src/main/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatter.java index 3697f48d653..4969ba503f2 100644 --- a/src/main/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatter.java +++ b/src/main/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatter.java @@ -1,7 +1,10 @@ package org.jabref.logic.formatter.casechanger; +import java.util.List; + import org.jabref.logic.cleanup.Formatter; import org.jabref.logic.l10n.Localization; +import org.jabref.model.strings.StringUtil; public class SentenceCaseFormatter extends Formatter { @@ -20,11 +23,17 @@ public String getKey() { */ @Override public String format(String input) { - Title title = new Title(new LowerCaseFormatter().format(input)); + List sentences = StringUtil.getStringAsSentences(input); + StringBuilder result = new StringBuilder(); + for (String sentence : sentences) { + Title title = new Title(new LowerCaseFormatter().format(sentence)); - title.getWords().stream().findFirst().ifPresent(Word::toUpperFirst); + title.getWords().stream().findFirst().ifPresent(Word::toUpperFirst); - return title.toString(); + result.append(title.toString() + " "); + } + result.deleteCharAt(result.length() - 1); + return result.toString(); } @Override diff --git a/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java b/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java index e70fd3a97fa..8c5d8fa1980 100644 --- a/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java +++ b/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java @@ -1,7 +1,10 @@ package org.jabref.logic.formatter.casechanger; +import java.util.List; + import org.jabref.logic.cleanup.Formatter; import org.jabref.logic.l10n.Localization; +import org.jabref.model.strings.StringUtil; public class TitleCaseFormatter extends Formatter { @@ -22,21 +25,26 @@ public String getKey() { */ @Override public String format(String input) { - Title title = new Title(input); + List sentences = StringUtil.getStringAsSentences(input); + StringBuilder result = new StringBuilder(); + for (String sentence : sentences) { + Title title = new Title(sentence); - title.getWords().stream().filter(Word::isSmallerWord).forEach(Word::toLowerCase); - title.getWords().stream().filter(Word::isLargerWord).forEach(Word::toUpperFirst); + title.getWords().stream().filter(Word::isSmallerWord).forEach(Word::toLowerCase); + title.getWords().stream().filter(Word::isLargerWord).forEach(Word::toUpperFirst); - title.getFirstWord().ifPresent(Word::toUpperFirst); - title.getLastWord().ifPresent(Word::toUpperFirst); + title.getFirstWord().ifPresent(Word::toUpperFirst); + title.getLastWord().ifPresent(Word::toUpperFirst); - for (int i = 0; i < (title.getWords().size() - 2); i++) { - if (title.getWords().get(i).endsWithColon()) { - title.getWords().get(i + 1).toUpperFirst(); + for (int i = 0; i < (title.getWords().size() - 2); i++) { + if (title.getWords().get(i).endsWithColon()) { + title.getWords().get(i + 1).toUpperFirst(); + } } + result.append(title.toString() + " "); } - - return title.toString(); + result.deleteCharAt(result.length() - 1); + return result.toString(); } @Override diff --git a/src/main/java/org/jabref/model/strings/StringUtil.java b/src/main/java/org/jabref/model/strings/StringUtil.java index 37267ce92cf..ec328a16a6c 100644 --- a/src/main/java/org/jabref/model/strings/StringUtil.java +++ b/src/main/java/org/jabref/model/strings/StringUtil.java @@ -720,6 +720,14 @@ public static List getStringAsWords(String text) { return Arrays.asList(text.split("[\\s,;]+")); } + /** + * Returns a list of sentences contained in the given text. + */ + public static List getStringAsSentences(String text) { + Pattern splitTextPattern = Pattern.compile("(?<=[\\.!;\\?])(? Date: Tue, 8 Sep 2020 18:38:49 +0200 Subject: [PATCH 2/7] fix checkstyle issues --- ...e-regular-expression-to-split-multiple-sentence-titles.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md b/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md index 2722c7d5a1f..999baaaeb9f 100644 --- a/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md +++ b/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md @@ -8,7 +8,7 @@ Some entry titles are composed of multiple sentences, for example: "Whose Music? * [Regular expression](https://docs.oracle.com/javase/tutorial/essential/regex/) * [OpenNLP](https://opennlp.apache.org/) -* [ICU4J](http://site.icu-project.org/home) - +* [ICU4J](http://site.icu-project.org/home) ## Decision Outcome @@ -22,4 +22,5 @@ Chosen option: "Regular expression", because we can use Java internal classes (P ### Negative Consequences -* Regular expressions can never cover every case, therefore, splitting may not be accurate for every title \ No newline at end of file +* Regular expressions can never cover every case, therefore, splitting may not be accurate for every title + From 4a9ff15e508caab4dce607bf652cf4ea6a855921 Mon Sep 17 00:00:00 2001 From: tmrd993 Date: Mon, 21 Sep 2020 16:46:37 +0200 Subject: [PATCH 3/7] refactor sentence case and title case format method, add additional info to ADR --- ...ssion-to-split-multiple-sentence-titles.md | 2 +- .../casechanger/SentenceCaseFormatter.java | 23 +++++---- .../casechanger/TitleCaseFormatter.java | 47 ++++++++++--------- .../org/jabref/model/strings/StringUtil.java | 3 +- 4 files changed, 40 insertions(+), 35 deletions(-) diff --git a/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md b/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md index 999baaaeb9f..2b50f04b513 100644 --- a/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md +++ b/docs/adr/0017-use-regular-expression-to-split-multiple-sentence-titles.md @@ -2,7 +2,7 @@ ## Context and Problem Statement -Some entry titles are composed of multiple sentences, for example: "Whose Music? A Sociology of Musical Language", therefore, it is necessary to first split the title into sentences and process them individually to ensure proper formatting using 'Sentence Case' or 'Title Case' +Some entry titles are composed of multiple sentences, for example: "Whose Music? A Sociology of Musical Language", therefore, it is necessary to first split the title into sentences and process them individually to ensure proper formatting using '[Sentence Case](https://en.wiktionary.org/wiki/sentence_case)' or '[Title Case](https://en.wiktionary.org/wiki/title_case#English)' ## Considered Options diff --git a/src/main/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatter.java b/src/main/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatter.java index 4969ba503f2..5f73c4839db 100644 --- a/src/main/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatter.java +++ b/src/main/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatter.java @@ -1,6 +1,6 @@ package org.jabref.logic.formatter.casechanger; -import java.util.List; +import java.util.stream.Collectors; import org.jabref.logic.cleanup.Formatter; import org.jabref.logic.l10n.Localization; @@ -23,17 +23,16 @@ public String getKey() { */ @Override public String format(String input) { - List sentences = StringUtil.getStringAsSentences(input); - StringBuilder result = new StringBuilder(); - for (String sentence : sentences) { - Title title = new Title(new LowerCaseFormatter().format(sentence)); - - title.getWords().stream().findFirst().ifPresent(Word::toUpperFirst); - - result.append(title.toString() + " "); - } - result.deleteCharAt(result.length() - 1); - return result.toString(); + return StringUtil.getStringAsSentences(input) + .stream() + .map(new LowerCaseFormatter()::format) + .map(Title::new) + .map(title -> { + title.getFirstWord().ifPresent(Word::toUpperFirst); + return title; + }) + .map(Object::toString) + .collect(Collectors.joining(" ")); } @Override diff --git a/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java b/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java index 8c5d8fa1980..eb6795301f3 100644 --- a/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java +++ b/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java @@ -1,6 +1,6 @@ package org.jabref.logic.formatter.casechanger; -import java.util.List; +import java.util.stream.Collectors; import org.jabref.logic.cleanup.Formatter; import org.jabref.logic.l10n.Localization; @@ -25,26 +25,31 @@ public String getKey() { */ @Override public String format(String input) { - List sentences = StringUtil.getStringAsSentences(input); - StringBuilder result = new StringBuilder(); - for (String sentence : sentences) { - Title title = new Title(sentence); - - title.getWords().stream().filter(Word::isSmallerWord).forEach(Word::toLowerCase); - title.getWords().stream().filter(Word::isLargerWord).forEach(Word::toUpperFirst); - - title.getFirstWord().ifPresent(Word::toUpperFirst); - title.getLastWord().ifPresent(Word::toUpperFirst); - - for (int i = 0; i < (title.getWords().size() - 2); i++) { - if (title.getWords().get(i).endsWithColon()) { - title.getWords().get(i + 1).toUpperFirst(); - } - } - result.append(title.toString() + " "); - } - result.deleteCharAt(result.length() - 1); - return result.toString(); + return StringUtil.getStringAsSentences(input) + .stream() + .map(sentence -> { + Title title = new Title(sentence); + + title.getWords().stream().filter(Word::isSmallerWord).forEach(Word::toLowerCase); + + title.getWords().stream().filter(Word::isLargerWord).forEach(Word::toUpperFirst); + + + title.getFirstWord().ifPresent(Word::toUpperFirst); + + title.getLastWord().ifPresent(Word::toUpperFirst); + + for (int i = 0; i < (title.getWords().size() - 2); i++) { + if (title.getWords().get(i).endsWithColon()) { + + title.getWords().get(i + 1).toUpperFirst(); + + } + } + + return title.toString(); + }) + .collect(Collectors.joining(" ")); } @Override diff --git a/src/main/java/org/jabref/model/strings/StringUtil.java b/src/main/java/org/jabref/model/strings/StringUtil.java index ec328a16a6c..2a5257ab16b 100644 --- a/src/main/java/org/jabref/model/strings/StringUtil.java +++ b/src/main/java/org/jabref/model/strings/StringUtil.java @@ -724,7 +724,8 @@ public static List getStringAsWords(String text) { * Returns a list of sentences contained in the given text. */ public static List getStringAsSentences(String text) { - Pattern splitTextPattern = Pattern.compile("(?<=[\\.!;\\?])(? Date: Tue, 22 Sep 2020 11:37:22 +0200 Subject: [PATCH 4/7] refactor titlecase and sentencecase tests --- .../SentenceCaseFormatterTest.java | 80 +++++++------------ .../casechanger/TitleCaseFormatterTest.java | 45 ++++++++++- 2 files changed, 72 insertions(+), 53 deletions(-) diff --git a/src/test/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatterTest.java b/src/test/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatterTest.java index a7daf02557a..02d90aff4b6 100644 --- a/src/test/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatterTest.java +++ b/src/test/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatterTest.java @@ -1,7 +1,10 @@ package org.jabref.logic.formatter.casechanger; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import java.util.stream.Stream; + +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -10,53 +13,30 @@ */ public class SentenceCaseFormatterTest { - private SentenceCaseFormatter formatter; - - @BeforeEach - public void setUp() { - formatter = new SentenceCaseFormatter(); - } - - @Test - public void test() { - assertEquals("Upper first", formatter.format("upper First")); - assertEquals("Upper first", formatter.format("uPPER FIRST")); - assertEquals("Upper {NOT} first", formatter.format("upper {NOT} FIRST")); - assertEquals("Upper {N}ot first", formatter.format("upper {N}OT FIRST")); - } - - @Test - public void secondSentenceAfterQuestionMarkGetsCapitalized() { - assertEquals("Whose music? A sociology of musical language", - formatter.format("Whose music? a sociology of musical language")); - } - - @Test - public void testSimpleTwoSentenceTitle() { - assertEquals("Bibliographic software. A comparison.", - formatter.format("bibliographic software. a comparison.")); - } - - @Test - public void sentenceAfterSemicolonGetsCapitalized() { - assertEquals("England’s monitor; The history of the separation", - formatter.format("England’s Monitor; the History of the Separation")); - } - - @Test - public void commonAbbreviationIsNotTreatedAsSeperateSentence() { - assertEquals("Dr. schultz: a dentist turned bounty hunter.", - formatter.format("Dr. schultz: a dentist turned bounty hunter.")); - } - - @Test - public void secondSentenceInBracketsIsLeftUnchanged() { - assertEquals("Example case. {EXCLUDED SENTENCE.}", - formatter.format("Example case. {EXCLUDED SENTENCE.}")); - } - - @Test - public void formatExample() { - assertEquals("I have {Aa} dream", formatter.format(formatter.getExampleInput())); + private final SentenceCaseFormatter formatter = new SentenceCaseFormatter(); + + private static Stream testData() { + return Stream.of( + Arguments.of("Upper first", "upper First"), + Arguments.of("Upper first", "uPPER FIRST"), + Arguments.of("Upper {NOT} first", "upper {NOT} FIRST"), + Arguments.of("Upper {N}ot first", "upper {N}OT FIRST"), + Arguments.of("Whose music? A sociology of musical language", + "Whose music? a sociology of musical language"), + Arguments.of("Bibliographic software. A comparison.", + "bibliographic software. a comparison."), + Arguments.of("England’s monitor; The history of the separation", + "England’s Monitor; the History of the Separation"), + Arguments.of("Dr. schultz: a dentist turned bounty hunter.", + "Dr. schultz: a dentist turned bounty hunter."), + Arguments.of("Example case. {EXCLUDED SENTENCE.}", + "Example case. {EXCLUDED SENTENCE.}"), + Arguments.of("I have {Aa} dream", new SentenceCaseFormatter().getExampleInput())); + } + + @ParameterizedTest + @MethodSource("testData") + public void test(String expected, String input) { + assertEquals(expected, formatter.format(input)); } } diff --git a/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java b/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java index ad4f67c5067..7c78def3a3a 100644 --- a/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java +++ b/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java @@ -1,7 +1,10 @@ package org.jabref.logic.formatter.casechanger; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import java.util.stream.Stream; + +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -10,8 +13,43 @@ */ public class TitleCaseFormatterTest { - private TitleCaseFormatter formatter; + private final TitleCaseFormatter formatter = new TitleCaseFormatter(); + + private static Stream testData() { + return Stream.of( + Arguments.of("Upper Each First", "upper each first"), + Arguments.of("Upper Each First", "upper eACH first"), + Arguments.of("An Upper Each First And", "an upper each first and"), + Arguments.of("An Upper Each First And", "an upper each first AND"), + Arguments.of("An Upper Each of the and First And", + "an upper each of the and first and"), + Arguments.of("An Upper Each of the and First And", + "an upper each of the AND first and"), + Arguments.of("An Upper Each of: The and First And", + "an upper each of: the and first and"), + Arguments.of("An Upper First with and without {CURLY} {brackets}", + "AN UPPER FIRST WITH AND WITHOUT {CURLY} {brackets}"), + Arguments.of("An Upper First with {A}nd without {C}urly {b}rackets", + "AN UPPER FIRST WITH {A}ND WITHOUT {C}URLY {b}rackets"), + Arguments.of("{b}rackets {b}rac{K}ets Brack{E}ts", + "{b}RaCKeTS {b}RaC{K}eTS bRaCK{E}ts"), + Arguments.of("Two Experiences Designing for Effective Security", + "Two experiences designing for effective security"), + Arguments.of("Bibliographic Software. A Comparison.", + "bibliographic software. a comparison."), + Arguments.of("Bibliographic Software. {A COMPARISON.}", + "bibliographic software. {A COMPARISON.}"), + Arguments.of("{BPMN} Conformance in Open Source Engines", + new TitleCaseFormatter().getExampleInput())); + } + + @ParameterizedTest + @MethodSource("testData") + public void test(String expected, String input) { + assertEquals(expected, formatter.format(input)); + } + /* @BeforeEach public void setUp() { formatter = new TitleCaseFormatter(); @@ -96,4 +134,5 @@ public void secondSentenceInBracketsIsLeftUnchanged() { public void formatExample() { assertEquals("{BPMN} Conformance in Open Source Engines", formatter.format(formatter.getExampleInput())); } + */ } From f9f05a93bf6cbf694a7b305bff3d4f833b812909 Mon Sep 17 00:00:00 2001 From: tmrd993 Date: Wed, 23 Sep 2020 12:37:35 +0200 Subject: [PATCH 5/7] fix checkstyle issues --- .../formatter/casechanger/TitleCaseFormatter.java | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java b/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java index eb6795301f3..19012649afe 100644 --- a/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java +++ b/src/main/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatter.java @@ -29,24 +29,19 @@ public String format(String input) { .stream() .map(sentence -> { Title title = new Title(sentence); - + title.getWords().stream().filter(Word::isSmallerWord).forEach(Word::toLowerCase); - title.getWords().stream().filter(Word::isLargerWord).forEach(Word::toUpperFirst); - - + title.getFirstWord().ifPresent(Word::toUpperFirst); - title.getLastWord().ifPresent(Word::toUpperFirst); - + for (int i = 0; i < (title.getWords().size() - 2); i++) { if (title.getWords().get(i).endsWithColon()) { - title.getWords().get(i + 1).toUpperFirst(); - } } - + return title.toString(); }) .collect(Collectors.joining(" ")); From 856c4a7a68d0be38f9f3b519415e14ccc4fa5160 Mon Sep 17 00:00:00 2001 From: tmrd993 Date: Wed, 23 Sep 2020 13:05:50 +0200 Subject: [PATCH 6/7] fix checkstyle issues --- .../logic/formatter/casechanger/SentenceCaseFormatterTest.java | 2 +- .../logic/formatter/casechanger/TitleCaseFormatterTest.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatterTest.java b/src/test/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatterTest.java index 02d90aff4b6..c9035ff5eb4 100644 --- a/src/test/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatterTest.java +++ b/src/test/java/org/jabref/logic/formatter/casechanger/SentenceCaseFormatterTest.java @@ -2,8 +2,8 @@ import java.util.stream.Stream; -import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java b/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java index 7c78def3a3a..15122d2d89b 100644 --- a/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java +++ b/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java @@ -2,8 +2,8 @@ import java.util.stream.Stream; -import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import static org.junit.jupiter.api.Assertions.assertEquals; From 9237d0743d1cfba6275bc5ac7fe1682231a98577 Mon Sep 17 00:00:00 2001 From: tmrd993 Date: Wed, 23 Sep 2020 17:55:00 +0200 Subject: [PATCH 7/7] remove redundant test cases --- .../casechanger/TitleCaseFormatterTest.java | 87 ------------------- 1 file changed, 87 deletions(-) diff --git a/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java b/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java index 15122d2d89b..3d0ffe87e7c 100644 --- a/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java +++ b/src/test/java/org/jabref/logic/formatter/casechanger/TitleCaseFormatterTest.java @@ -48,91 +48,4 @@ private static Stream testData() { public void test(String expected, String input) { assertEquals(expected, formatter.format(input)); } - - /* - @BeforeEach - public void setUp() { - formatter = new TitleCaseFormatter(); - } - - @Test - public void eachFirstLetterIsUppercased() { - assertEquals("Upper Each First", formatter.format("upper each first")); - } - - @Test - public void eachFirstLetterIsUppercasedAndOthersLowercased() { - assertEquals("Upper Each First", formatter.format("upper eACH first")); - } - - @Test - public void eachFirstLetterIsUppercasedAndATralingAndIsAlsoUppercased() { - assertEquals("An Upper Each First And", formatter.format("an upper each first and")); - } - - @Test - public void eachFirstLetterIsUppercasedAndATralingAndIsAlsoCorrectlyCased() { - assertEquals("An Upper Each First And", formatter.format("an upper each first AND")); - } - - @Test - public void eachFirstLetterIsUppercasedButIntermediateAndsAreKeptLowercase() { - assertEquals("An Upper Each of the and First And", - formatter.format("an upper each of the and first and")); - } - - @Test - public void eachFirstLetterIsUppercasedButIntermediateAndsArePutLowercase() { - assertEquals("An Upper Each of the and First And", - formatter.format("an upper each of the AND first and")); - } - - @Test - public void theAfterColonGetsCapitalized() { - assertEquals("An Upper Each of: The and First And", - formatter.format("an upper each of: the and first and")); - } - - @Test - public void completeWordsInCurlyBracketsIsLeftUnchanged() { - assertEquals("An Upper First with and without {CURLY} {brackets}", - formatter.format("AN UPPER FIRST WITH AND WITHOUT {CURLY} {brackets}")); - } - - @Test - public void lettersInCurlyBracketsIsLeftUnchanged() { - assertEquals("An Upper First with {A}nd without {C}urly {b}rackets", - formatter.format("AN UPPER FIRST WITH {A}ND WITHOUT {C}URLY {b}rackets")); - } - - @Test - public void intraWordLettersInCurlyBracketsIsLeftUnchanged() { - assertEquals("{b}rackets {b}rac{K}ets Brack{E}ts", - formatter.format("{b}RaCKeTS {b}RaC{K}eTS bRaCK{E}ts")); - } - - @Test - public void testTwoExperiencesTitle() { - assertEquals( - "Two Experiences Designing for Effective Security", - formatter.format("Two experiences designing for effective security")); - } - - @Test - public void testSimpleTwoSentenceTitle() { - assertEquals("Bibliographic Software. A Comparison.", - formatter.format("bibliographic software. a comparison.")); - } - - @Test - public void secondSentenceInBracketsIsLeftUnchanged() { - assertEquals("Bibliographic Software. {A COMPARISON.}", - formatter.format("bibliographic software. {A COMPARISON.}")); - } - - @Test - public void formatExample() { - assertEquals("{BPMN} Conformance in Open Source Engines", formatter.format(formatter.getExampleInput())); - } - */ }