From f5dca6696906b625d038b6b920ee207eccae5348 Mon Sep 17 00:00:00 2001 From: Madhumita Gopal Date: Wed, 25 Jul 2018 13:24:28 +0530 Subject: [PATCH 1/5] adding the required classes for binding example --- .../java/com/baeldung/binding/Animal.java | 23 ++++++++++ .../com/baeldung/binding/AnimalActivity.java | 43 +++++++++++++++++++ .../main/java/com/baeldung/binding/Dog.java | 18 ++++++++ .../binding/AnimalActivityUnitTest.java | 8 ++++ 4 files changed, 92 insertions(+) create mode 100644 core-java/src/main/java/com/baeldung/binding/Animal.java create mode 100644 core-java/src/main/java/com/baeldung/binding/AnimalActivity.java create mode 100644 core-java/src/main/java/com/baeldung/binding/Dog.java create mode 100644 core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java diff --git a/core-java/src/main/java/com/baeldung/binding/Animal.java b/core-java/src/main/java/com/baeldung/binding/Animal.java new file mode 100644 index 000000000000..12eaa2a7a385 --- /dev/null +++ b/core-java/src/main/java/com/baeldung/binding/Animal.java @@ -0,0 +1,23 @@ +package com.baeldung.binding; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Created by madhumita.g on 25-07-2018. + */ +public class Animal { + + final static Logger logger = LoggerFactory.getLogger(Animal.class); + + public void makeNoise() { + logger.info("generic animal noise"); + } + + public void makeNoise(Integer repetitions) { + while(repetitions != 0) { + logger.info("generic animal noise countdown " + repetitions); + repetitions -= 1; + } + } +} diff --git a/core-java/src/main/java/com/baeldung/binding/AnimalActivity.java b/core-java/src/main/java/com/baeldung/binding/AnimalActivity.java new file mode 100644 index 000000000000..4014e9549e4c --- /dev/null +++ b/core-java/src/main/java/com/baeldung/binding/AnimalActivity.java @@ -0,0 +1,43 @@ +package com.baeldung.binding; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Created by madhumita.g on 25-07-2018. + */ +public class AnimalActivity { + + final static Logger logger = LoggerFactory.getLogger(AnimalActivity.class); + + + public static void eat(Animal animal) { + logger.info("Animal is eating"); + } + + public static void eat(Dog dog) { + logger.info("Dog is eating"); + } + + public static void main(String[] args) { + + Animal animal = new Animal(); + + //calling methods of animal object + animal.makeNoise(); + + animal.makeNoise(3); + + + //assigning a dog object to reference of type Animal + Animal dogAnimal = new Dog(); + + dogAnimal.makeNoise(); + + // calling static function + AnimalActivity.eat(dogAnimal); + + return; + + } +} diff --git a/core-java/src/main/java/com/baeldung/binding/Dog.java b/core-java/src/main/java/com/baeldung/binding/Dog.java new file mode 100644 index 000000000000..6ae74cba4e2d --- /dev/null +++ b/core-java/src/main/java/com/baeldung/binding/Dog.java @@ -0,0 +1,18 @@ +package com.baeldung.binding; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Created by madhumita.g on 25-07-2018. + */ +public class Dog extends Animal { + + final static Logger logger = LoggerFactory.getLogger(Dog.class); + + public void makeNoise() { + + logger.info("woof woof!"); + } + +} diff --git a/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java b/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java new file mode 100644 index 000000000000..31734a627f64 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java @@ -0,0 +1,8 @@ +package com.baeldung.binding; + +/** + * Created by madhumita.g on 25-07-2018. + */ +public class AnimalActivityUnitTest { + +} From 85d1b3cc277853ba10351cd586251439c323e8ee Mon Sep 17 00:00:00 2001 From: Madhumita Gopal Date: Wed, 1 Aug 2018 01:22:23 +0530 Subject: [PATCH 2/5] completed test class for AnimalActivityUnitTest static functions --- .../binding/AnimalActivityUnitTest.java | 90 ++++++++++++++++++- 1 file changed, 88 insertions(+), 2 deletions(-) diff --git a/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java b/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java index 31734a627f64..c2e2c75b76ab 100644 --- a/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java +++ b/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java @@ -1,8 +1,94 @@ package com.baeldung.binding; +import ch.qos.logback.classic.Level; +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.spi.LoggingEvent; +import ch.qos.logback.core.Appender; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; +import org.slf4j.LoggerFactory; + +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; +import static org.mockito.Mockito.verify; + /** - * Created by madhumita.g on 25-07-2018. +*https://gist.github.com/bloodredsun/a041de13e57bf3c6c040 */ +@RunWith(MockitoJUnitRunner.class) public class AnimalActivityUnitTest { -} + @Mock + private Appender mockAppender; + @Captor + private ArgumentCaptor captorLoggingEvent; + + @Before + public void setup() { + final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + logger.addAppender(mockAppender); + } + + @After + public void teardown() { + final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + logger.detachAppender(mockAppender); + } + + @Test + public void givenAnimalReference__whenRefersAnimalObject_shouldCallFunctionWithAnimalParam() { + + Animal animal = new Animal(); + + AnimalActivity.eat(animal); + + verify(mockAppender).doAppend(captorLoggingEvent.capture()); + + final LoggingEvent loggingEvent = captorLoggingEvent.getValue(); + + assertThat(loggingEvent.getLevel(), is(Level.INFO)); + + assertThat(loggingEvent.getFormattedMessage(), + is("Animal is eating")); + } + + @Test + public void givenDogReference__whenRefersDogObject_shouldCallFunctionWithAnimalParam() { + + Dog dog = new Dog(); + + AnimalActivity.eat(dog); + + verify(mockAppender).doAppend(captorLoggingEvent.capture()); + + final LoggingEvent loggingEvent = captorLoggingEvent.getValue(); + + assertThat(loggingEvent.getLevel(), is(Level.INFO)); + + assertThat(loggingEvent.getFormattedMessage(), + is("Dog is eating")); + } + + @Test + public void givenAnimaReference__whenRefersDogObject_shouldCallFunctionWithAnimalParam() { + + Animal dog = new Dog(); + + AnimalActivity.eat(dog); + + verify(mockAppender).doAppend(captorLoggingEvent.capture()); + + final LoggingEvent loggingEvent = captorLoggingEvent.getValue(); + + assertThat(loggingEvent.getLevel(), is(Level.INFO)); + + assertThat(loggingEvent.getFormattedMessage(), + is("Animal is eating")); + } +} \ No newline at end of file From e57c2910fef3498e44cbcfd2b2464f915aa6ece3 Mon Sep 17 00:00:00 2001 From: Madhumita Gopal Date: Tue, 7 Aug 2018 13:34:07 +0530 Subject: [PATCH 3/5] changes to example so that they don't seem to be a replica of https://stackoverflow.com/questions/19017258/static-vs-dynamic-binding-in-java --- .../com/baeldung/binding/AnimalActivity.java | 14 ++-- .../baeldung/binding/{Dog.java => Cat.java} | 6 +- .../binding/AnimalActivityUnitTest.java | 16 ++--- .../com/baeldung/binding/AnimalUnitTest.java | 71 +++++++++++++++++++ .../com/baeldung/binding/CatUnitTest.java | 7 ++ .../baeldung/java/regex/RegexUnitTest.java | 8 +-- 6 files changed, 100 insertions(+), 22 deletions(-) rename core-java/src/main/java/com/baeldung/binding/{Dog.java => Cat.java} (58%) create mode 100644 core-java/src/test/java/com/baeldung/binding/AnimalUnitTest.java create mode 100644 core-java/src/test/java/com/baeldung/binding/CatUnitTest.java diff --git a/core-java/src/main/java/com/baeldung/binding/AnimalActivity.java b/core-java/src/main/java/com/baeldung/binding/AnimalActivity.java index 4014e9549e4c..1bd36123e371 100644 --- a/core-java/src/main/java/com/baeldung/binding/AnimalActivity.java +++ b/core-java/src/main/java/com/baeldung/binding/AnimalActivity.java @@ -11,12 +11,12 @@ public class AnimalActivity { final static Logger logger = LoggerFactory.getLogger(AnimalActivity.class); - public static void eat(Animal animal) { - logger.info("Animal is eating"); + public static void sleep(Animal animal) { + logger.info("Animal is sleeping"); } - public static void eat(Dog dog) { - logger.info("Dog is eating"); + public static void sleep(Cat cat) { + logger.info("Cat is sleeping"); } public static void main(String[] args) { @@ -30,12 +30,12 @@ public static void main(String[] args) { //assigning a dog object to reference of type Animal - Animal dogAnimal = new Dog(); + Animal catAnimal = new Cat(); - dogAnimal.makeNoise(); + catAnimal.makeNoise(); // calling static function - AnimalActivity.eat(dogAnimal); + AnimalActivity.sleep(catAnimal); return; diff --git a/core-java/src/main/java/com/baeldung/binding/Dog.java b/core-java/src/main/java/com/baeldung/binding/Cat.java similarity index 58% rename from core-java/src/main/java/com/baeldung/binding/Dog.java rename to core-java/src/main/java/com/baeldung/binding/Cat.java index 6ae74cba4e2d..bbe740e41226 100644 --- a/core-java/src/main/java/com/baeldung/binding/Dog.java +++ b/core-java/src/main/java/com/baeldung/binding/Cat.java @@ -6,13 +6,13 @@ /** * Created by madhumita.g on 25-07-2018. */ -public class Dog extends Animal { +public class Cat extends Animal { - final static Logger logger = LoggerFactory.getLogger(Dog.class); + final static Logger logger = LoggerFactory.getLogger(Cat.class); public void makeNoise() { - logger.info("woof woof!"); + logger.info("meow"); } } diff --git a/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java b/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java index c2e2c75b76ab..3dcb0e26f44d 100644 --- a/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java +++ b/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java @@ -46,7 +46,7 @@ public void givenAnimalReference__whenRefersAnimalObject_shouldCallFunctionWithA Animal animal = new Animal(); - AnimalActivity.eat(animal); + AnimalActivity.sleep(animal); verify(mockAppender).doAppend(captorLoggingEvent.capture()); @@ -55,15 +55,15 @@ public void givenAnimalReference__whenRefersAnimalObject_shouldCallFunctionWithA assertThat(loggingEvent.getLevel(), is(Level.INFO)); assertThat(loggingEvent.getFormattedMessage(), - is("Animal is eating")); + is("Animal is sleeping")); } @Test public void givenDogReference__whenRefersDogObject_shouldCallFunctionWithAnimalParam() { - Dog dog = new Dog(); + Cat cat = new Cat(); - AnimalActivity.eat(dog); + AnimalActivity.sleep(cat); verify(mockAppender).doAppend(captorLoggingEvent.capture()); @@ -72,15 +72,15 @@ public void givenDogReference__whenRefersDogObject_shouldCallFunctionWithAnimalP assertThat(loggingEvent.getLevel(), is(Level.INFO)); assertThat(loggingEvent.getFormattedMessage(), - is("Dog is eating")); + is("Cat is sleeping")); } @Test public void givenAnimaReference__whenRefersDogObject_shouldCallFunctionWithAnimalParam() { - Animal dog = new Dog(); + Animal cat = new Cat(); - AnimalActivity.eat(dog); + AnimalActivity.sleep(cat); verify(mockAppender).doAppend(captorLoggingEvent.capture()); @@ -89,6 +89,6 @@ public void givenAnimaReference__whenRefersDogObject_shouldCallFunctionWithAnima assertThat(loggingEvent.getLevel(), is(Level.INFO)); assertThat(loggingEvent.getFormattedMessage(), - is("Animal is eating")); + is("Animal is sleeping")); } } \ No newline at end of file diff --git a/core-java/src/test/java/com/baeldung/binding/AnimalUnitTest.java b/core-java/src/test/java/com/baeldung/binding/AnimalUnitTest.java new file mode 100644 index 000000000000..7d4d12ea2200 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/binding/AnimalUnitTest.java @@ -0,0 +1,71 @@ +package com.baeldung.binding; + +import ch.qos.logback.classic.Level; +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.spi.LoggingEvent; +import ch.qos.logback.core.Appender; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; +import org.slf4j.LoggerFactory; + +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; +import static org.mockito.Mockito.verify; + +/** + * Created by madhumita.g on 01-08-2018. + */ + +@RunWith(MockitoJUnitRunner.class) +public class AnimalUnitTest { + @Mock + private Appender mockAppender; + @Captor + private ArgumentCaptor captorLoggingEvent; + + @Before + public void setup() { + final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + logger.addAppender(mockAppender); + } + + @After + public void teardown() { + final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + logger.detachAppender(mockAppender); + } + + @Test + public void overloadinTesting() { + + Animal animal = new Animal(); + + animal.makeNoise(); + + verify(mockAppender).doAppend(captorLoggingEvent.capture()); + + final LoggingEvent loggingEvent = captorLoggingEvent.getValue(); + + assertThat(loggingEvent.getLevel(), is(Level.INFO)); + + assertThat(loggingEvent.getFormattedMessage(), + is("generic animal noise")); + + animal.makeNoise(3); + + assertThat(loggingEvent.getLevel(), is(Level.INFO)); + + assertThat(loggingEvent.getFormattedMessage(), + is("generic animal noise countdown 3\n" + + "generic animal noise countdown 2\n" + + "generic animal noise countdown 1\n")); + + } + +} diff --git a/core-java/src/test/java/com/baeldung/binding/CatUnitTest.java b/core-java/src/test/java/com/baeldung/binding/CatUnitTest.java new file mode 100644 index 000000000000..f121ccfd9af1 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/binding/CatUnitTest.java @@ -0,0 +1,7 @@ +package com.baeldung.binding; + +/** + * Created by madhumita.g on 01-08-2018. + */ +public class CatUnitTest { +} diff --git a/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java b/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java index e4ea55aae3e6..52990237d17c 100644 --- a/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java +++ b/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java @@ -71,7 +71,7 @@ public void givenNORSet_whenMatchesNon_thenCorrect() { @Test public void givenNORSet_whenMatchesAllExceptElements_thenCorrect() { - int matches = runTest("[^bcr]at", "sat mat eat"); + int matches = runTest("[^bcr]at", "sat mat sleep"); assertTrue(matches > 0); } @@ -343,19 +343,19 @@ public void givenRegexWithCanonEq_whenMatchesOnEquivalentUnicode_thenCorrect() { @Test public void givenRegexWithDefaultMatcher_whenMatchFailsOnDifferentCases_thenCorrect() { - int matches = runTest("dog", "This is a Dog"); + int matches = runTest("dog", "This is a Cat"); assertFalse(matches > 0); } @Test public void givenRegexWithCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() { - int matches = runTest("dog", "This is a Dog", Pattern.CASE_INSENSITIVE); + int matches = runTest("dog", "This is a Cat", Pattern.CASE_INSENSITIVE); assertTrue(matches > 0); } @Test public void givenRegexWithEmbeddedCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() { - int matches = runTest("(?i)dog", "This is a Dog"); + int matches = runTest("(?i)dog", "This is a Cat"); assertTrue(matches > 0); } From 7e5857acbc9df8d72ecbdb857fcf7717c4771910 Mon Sep 17 00:00:00 2001 From: Madhumita Gopal Date: Sat, 11 Aug 2018 11:58:28 +0530 Subject: [PATCH 4/5] refactoring and removing unnecessary file --- .../binding/AnimalActivityUnitTest.java | 7 +- .../com/baeldung/binding/AnimalUnitTest.java | 31 +- .../com/baeldung/binding/CatUnitTest.java | 55 ++ .../baeldung/java/regex/RegexUnitTest.java | 501 ------------------ 4 files changed, 82 insertions(+), 512 deletions(-) delete mode 100644 core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java diff --git a/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java b/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java index 3dcb0e26f44d..41c67ff389ad 100644 --- a/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java +++ b/core-java/src/test/java/com/baeldung/binding/AnimalActivityUnitTest.java @@ -11,7 +11,7 @@ import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.Mock; -import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.junit.MockitoJUnitRunner; import org.slf4j.LoggerFactory; import static org.hamcrest.CoreMatchers.is; @@ -19,9 +19,10 @@ import static org.mockito.Mockito.verify; /** -*https://gist.github.com/bloodredsun/a041de13e57bf3c6c040 + *https://gist.github.com/bloodredsun/a041de13e57bf3c6c040 */ @RunWith(MockitoJUnitRunner.class) + public class AnimalActivityUnitTest { @Mock @@ -59,7 +60,7 @@ public void givenAnimalReference__whenRefersAnimalObject_shouldCallFunctionWithA } @Test - public void givenDogReference__whenRefersDogObject_shouldCallFunctionWithAnimalParam() { + public void givenDogReference__whenRefersCatObject_shouldCallFunctionWithAnimalParam() { Cat cat = new Cat(); diff --git a/core-java/src/test/java/com/baeldung/binding/AnimalUnitTest.java b/core-java/src/test/java/com/baeldung/binding/AnimalUnitTest.java index 7d4d12ea2200..238990f2b457 100644 --- a/core-java/src/test/java/com/baeldung/binding/AnimalUnitTest.java +++ b/core-java/src/test/java/com/baeldung/binding/AnimalUnitTest.java @@ -11,7 +11,7 @@ import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.Mock; -import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.junit.MockitoJUnitRunner; import org.slf4j.LoggerFactory; import static org.hamcrest.CoreMatchers.is; @@ -42,7 +42,7 @@ public void teardown() { } @Test - public void overloadinTesting() { + public void whenCalledWithoutParameters_shouldCallFunctionMakeNoiseWithoutParameters() { Animal animal = new Animal(); @@ -56,16 +56,31 @@ public void overloadinTesting() { assertThat(loggingEvent.getFormattedMessage(), is("generic animal noise")); + } - animal.makeNoise(3); + @Test + public void whenCalledWithParameters_shouldCallFunctionMakeNoiseWithParameters() { - assertThat(loggingEvent.getLevel(), is(Level.INFO)); + Animal animal = new Animal(); - assertThat(loggingEvent.getFormattedMessage(), - is("generic animal noise countdown 3\n" - + "generic animal noise countdown 2\n" - + "generic animal noise countdown 1\n")); + int testValue = 3; + animal.makeNoise(testValue); + + verify(mockAppender).doAppend(captorLoggingEvent.capture()); + + final LoggingEvent loggingEvent = captorLoggingEvent.getValue(); + + while (testValue != 0) { + assertThat(loggingEvent.getLevel(), is(Level.INFO)); + + assertThat(loggingEvent.getFormattedMessage(), + is("generic animal noise countdown 3\n" + + "generic animal noise countdown 2\n" + + "generic animal noise countdown 1\n")); + + testValue-=1; + } } } diff --git a/core-java/src/test/java/com/baeldung/binding/CatUnitTest.java b/core-java/src/test/java/com/baeldung/binding/CatUnitTest.java index f121ccfd9af1..76ccfb771988 100644 --- a/core-java/src/test/java/com/baeldung/binding/CatUnitTest.java +++ b/core-java/src/test/java/com/baeldung/binding/CatUnitTest.java @@ -1,7 +1,62 @@ package com.baeldung.binding; +import ch.qos.logback.classic.Level; +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.spi.LoggingEvent; +import ch.qos.logback.core.Appender; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.slf4j.LoggerFactory; + +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; +import static org.mockito.Mockito.verify; + /** * Created by madhumita.g on 01-08-2018. */ +@RunWith(MockitoJUnitRunner.class) public class CatUnitTest { + + @Mock + private Appender mockAppender; + + @Captor + private ArgumentCaptor captorLoggingEvent; + + @Before + public void setup() { + final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + logger.addAppender(mockAppender); + } + + @After + public void teardown() { + final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); + logger.detachAppender(mockAppender); + } + + @Test + public void makeNoiseTest() { + + Cat cat = new Cat(); + + cat.makeNoise(); + + verify(mockAppender).doAppend(captorLoggingEvent.capture()); + + final LoggingEvent loggingEvent = captorLoggingEvent.getValue(); + + assertThat(loggingEvent.getLevel(), is(Level.INFO)); + + assertThat(loggingEvent.getFormattedMessage(), + is("meow")); + + } } diff --git a/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java b/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java deleted file mode 100644 index 52990237d17c..000000000000 --- a/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java +++ /dev/null @@ -1,501 +0,0 @@ -package com.baeldung.java.regex; - -import static org.junit.Assert.*; - -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import org.junit.Test; - -public class RegexUnitTest { - private static Pattern pattern; - private static Matcher matcher; - - @Test - public void givenText_whenSimpleRegexMatches_thenCorrect() { - Pattern pattern = Pattern.compile("foo"); - Matcher matcher = pattern.matcher("foo"); - assertTrue(matcher.find()); - } - - @Test - public void givenText_whenSimpleRegexMatchesTwice_thenCorrect() { - Pattern pattern = Pattern.compile("foo"); - Matcher matcher = pattern.matcher("foofoo"); - int matches = 0; - while (matcher.find()) - matches++; - assertEquals(matches, 2); - - } - - @Test - public void givenText_whenMatchesWithDotMetach_thenCorrect() { - int matches = runTest(".", "foo"); - assertTrue(matches > 0); - } - - @Test - public void givenRepeatedText_whenMatchesOnceWithDotMetach_thenCorrect() { - int matches = runTest("foo.", "foofoo"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenORSet_whenMatchesAny_thenCorrect() { - int matches = runTest("[abc]", "b"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenORSet_whenMatchesAnyAndAll_thenCorrect() { - int matches = runTest("[abc]", "cab"); - assertTrue(matches > 0); - assertEquals(matches, 3); - } - - @Test - public void givenORSet_whenMatchesAllCombinations_thenCorrect() { - int matches = runTest("[bcr]at", "bat cat rat"); - assertTrue(matches > 0); - assertEquals(matches, 3); - } - - @Test - public void givenNORSet_whenMatchesNon_thenCorrect() { - int matches = runTest("[^abc]", "g"); - assertTrue(matches > 0); - } - - @Test - public void givenNORSet_whenMatchesAllExceptElements_thenCorrect() { - int matches = runTest("[^bcr]at", "sat mat sleep"); - assertTrue(matches > 0); - } - - @Test - public void givenUpperCaseRange_whenMatchesUpperCase_thenCorrect() { - int matches = runTest("[A-Z]", "Two Uppercase alphabets 34 overall"); - assertTrue(matches > 0); - assertEquals(matches, 2); - } - - @Test - public void givenLowerCaseRange_whenMatchesLowerCase_thenCorrect() { - int matches = runTest("[a-z]", "Two Uppercase alphabets 34 overall"); - assertTrue(matches > 0); - assertEquals(matches, 26); - } - - @Test - public void givenBothLowerAndUpperCaseRange_whenMatchesAllLetters_thenCorrect() { - int matches = runTest("[a-zA-Z]", "Two Uppercase alphabets 34 overall"); - assertTrue(matches > 0); - assertEquals(matches, 28); - } - - @Test - public void givenNumberRange_whenMatchesAccurately_thenCorrect() { - int matches = runTest("[1-5]", "Two Uppercase alphabets 34 overall"); - assertTrue(matches > 0); - assertEquals(matches, 2); - } - - @Test - public void givenNumberRange_whenMatchesAccurately_thenCorrect2() { - int matches = runTest("[30-35]", "Two Uppercase alphabets 34 overall"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenTwoSets_whenMatchesUnion_thenCorrect() { - int matches = runTest("[1-3[7-9]]", "123456789"); - assertTrue(matches > 0); - assertEquals(matches, 6); - } - - @Test - public void givenTwoSets_whenMatchesIntersection_thenCorrect() { - int matches = runTest("[1-6&&[3-9]]", "123456789"); - assertTrue(matches > 0); - assertEquals(matches, 4); - } - - @Test - public void givenSetWithSubtraction_whenMatchesAccurately_thenCorrect() { - int matches = runTest("[0-9&&[^2468]]", "123456789"); - assertTrue(matches > 0); - assertEquals(matches, 5); - } - - @Test - public void givenDigits_whenMatches_thenCorrect() { - int matches = runTest("\\d", "123"); - assertTrue(matches > 0); - assertEquals(matches, 3); - } - - @Test - public void givenNonDigits_whenMatches_thenCorrect() { - int matches = runTest("\\D", "a6c"); - assertTrue(matches > 0); - assertEquals(matches, 2); - } - - @Test - public void givenWhiteSpace_whenMatches_thenCorrect() { - int matches = runTest("\\s", "a c"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenNonWhiteSpace_whenMatches_thenCorrect() { - int matches = runTest("\\S", "a c"); - assertTrue(matches > 0); - assertEquals(matches, 2); - } - - @Test - public void givenWordCharacter_whenMatches_thenCorrect() { - int matches = runTest("\\w", "hi!"); - assertTrue(matches > 0); - assertEquals(matches, 2); - } - - @Test - public void givenNonWordCharacter_whenMatches_thenCorrect() { - int matches = runTest("\\W", "hi!"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenZeroOrOneQuantifier_whenMatches_thenCorrect() { - int matches = runTest("\\a?", "hi"); - assertTrue(matches > 0); - assertEquals(matches, 3); - } - - @Test - public void givenZeroOrOneQuantifier_whenMatches_thenCorrect2() { - int matches = runTest("\\a{0,1}", "hi"); - assertTrue(matches > 0); - assertEquals(matches, 3); - } - - @Test - public void givenZeroOrManyQuantifier_whenMatches_thenCorrect() { - int matches = runTest("\\a*", "hi"); - assertTrue(matches > 0); - assertEquals(matches, 3); - } - - @Test - public void givenZeroOrManyQuantifier_whenMatches_thenCorrect2() { - int matches = runTest("\\a{0,}", "hi"); - assertTrue(matches > 0); - assertEquals(matches, 3); - } - - @Test - public void givenOneOrManyQuantifier_whenMatches_thenCorrect() { - int matches = runTest("\\a+", "hi"); - assertFalse(matches > 0); - } - - @Test - public void givenOneOrManyQuantifier_whenMatches_thenCorrect2() { - int matches = runTest("\\a{1,}", "hi"); - assertFalse(matches > 0); - } - - @Test - public void givenBraceQuantifier_whenMatches_thenCorrect() { - int matches = runTest("a{3}", "aaaaaa"); - assertTrue(matches > 0); - assertEquals(matches, 2); - } - - @Test - public void givenBraceQuantifier_whenFailsToMatch_thenCorrect() { - int matches = runTest("a{3}", "aa"); - assertFalse(matches > 0); - } - - @Test - public void givenBraceQuantifierWithRange_whenMatches_thenCorrect() { - int matches = runTest("a{2,3}", "aaaa"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenBraceQuantifierWithRange_whenMatchesLazily_thenCorrect() { - int matches = runTest("a{2,3}?", "aaaa"); - assertTrue(matches > 0); - assertEquals(matches, 2); - } - - @Test - public void givenCapturingGroup_whenMatches_thenCorrect() { - int matches = runTest("(\\d\\d)", "12"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenCapturingGroup_whenMatches_thenCorrect2() { - int matches = runTest("(\\d\\d)", "1212"); - assertTrue(matches > 0); - assertEquals(matches, 2); - } - - @Test - public void givenCapturingGroup_whenMatches_thenCorrect3() { - int matches = runTest("(\\d\\d)(\\d\\d)", "1212"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenCapturingGroup_whenMatchesWithBackReference_thenCorrect() { - int matches = runTest("(\\d\\d)\\1", "1212"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenCapturingGroup_whenMatchesWithBackReference_thenCorrect2() { - int matches = runTest("(\\d\\d)\\1\\1\\1", "12121212"); - assertTrue(matches > 0); - assertEquals(matches, 1); - } - - @Test - public void givenCapturingGroupAndWrongInput_whenMatchFailsWithBackReference_thenCorrect() { - int matches = runTest("(\\d\\d)\\1", "1213"); - assertFalse(matches > 0); - } - - @Test - public void givenText_whenMatchesAtBeginning_thenCorrect() { - int matches = runTest("^dog", "dogs are friendly"); - assertTrue(matches > 0); - } - - @Test - public void givenTextAndWrongInput_whenMatchFailsAtBeginning_thenCorrect() { - int matches = runTest("^dog", "are dogs are friendly?"); - assertFalse(matches > 0); - } - - @Test - public void givenText_whenMatchesAtEnd_thenCorrect() { - int matches = runTest("dog$", "Man's best friend is a dog"); - assertTrue(matches > 0); - } - - @Test - public void givenTextAndWrongInput_whenMatchFailsAtEnd_thenCorrect() { - int matches = runTest("dog$", "is a dog man's best friend?"); - assertFalse(matches > 0); - } - - @Test - public void givenText_whenMatchesAtWordBoundary_thenCorrect() { - int matches = runTest("\\bdog\\b", "a dog is friendly"); - assertTrue(matches > 0); - } - - @Test - public void givenText_whenMatchesAtWordBoundary_thenCorrect2() { - int matches = runTest("\\bdog\\b", "dog is man's best friend"); - assertTrue(matches > 0); - } - - @Test - public void givenWrongText_whenMatchFailsAtWordBoundary_thenCorrect() { - int matches = runTest("\\bdog\\b", "snoop dogg is a rapper"); - assertFalse(matches > 0); - } - - @Test - public void givenText_whenMatchesAtWordAndNonBoundary_thenCorrect() { - int matches = runTest("\\bdog\\B", "snoop dogg is a rapper"); - assertTrue(matches > 0); - } - - @Test - public void givenRegexWithoutCanonEq_whenMatchFailsOnEquivalentUnicode_thenCorrect() { - int matches = runTest("\u00E9", "\u0065\u0301"); - assertFalse(matches > 0); - } - - @Test - public void givenRegexWithCanonEq_whenMatchesOnEquivalentUnicode_thenCorrect() { - int matches = runTest("\u00E9", "\u0065\u0301", Pattern.CANON_EQ); - assertTrue(matches > 0); - } - - @Test - public void givenRegexWithDefaultMatcher_whenMatchFailsOnDifferentCases_thenCorrect() { - int matches = runTest("dog", "This is a Cat"); - assertFalse(matches > 0); - } - - @Test - public void givenRegexWithCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() { - int matches = runTest("dog", "This is a Cat", Pattern.CASE_INSENSITIVE); - assertTrue(matches > 0); - } - - @Test - public void givenRegexWithEmbeddedCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() { - int matches = runTest("(?i)dog", "This is a Cat"); - assertTrue(matches > 0); - } - - @Test - public void givenRegexWithComments_whenMatchFailsWithoutFlag_thenCorrect() { - int matches = runTest("dog$ #check for word dog at end of text", "This is a dog"); - assertFalse(matches > 0); - } - - @Test - public void givenRegexWithComments_whenMatchesWithFlag_thenCorrect() { - int matches = runTest("dog$ #check for word dog at end of text", "This is a dog", Pattern.COMMENTS); - assertTrue(matches > 0); - } - - @Test - public void givenRegexWithComments_whenMatchesWithEmbeddedFlag_thenCorrect() { - int matches = runTest("(?x)dog$ #check for word dog at end of text", "This is a dog"); - assertTrue(matches > 0); - } - - @Test - public void givenRegexWithLineTerminator_whenMatchFails_thenCorrect() { - Pattern pattern = Pattern.compile("(.*)"); - Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line"); - matcher.find(); - assertEquals("this is a text", matcher.group(1)); - } - - @Test - public void givenRegexWithLineTerminator_whenMatchesWithDotall_thenCorrect() { - Pattern pattern = Pattern.compile("(.*)", Pattern.DOTALL); - Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line"); - matcher.find(); - assertEquals("this is a text" + System.getProperty("line.separator") + " continued on another line", matcher.group(1)); - } - - @Test - public void givenRegexWithLineTerminator_whenMatchesWithEmbeddedDotall_thenCorrect() { - Pattern pattern = Pattern.compile("(?s)(.*)"); - Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line"); - matcher.find(); - assertEquals("this is a text" + System.getProperty("line.separator") + " continued on another line", matcher.group(1)); - } - - @Test - public void givenRegex_whenMatchesWithoutLiteralFlag_thenCorrect() { - int matches = runTest("(.*)", "text"); - assertTrue(matches > 0); - } - - @Test - public void givenRegex_whenMatchFailsWithLiteralFlag_thenCorrect() { - int matches = runTest("(.*)", "text", Pattern.LITERAL); - assertFalse(matches > 0); - } - - @Test - public void givenRegex_whenMatchesWithLiteralFlag_thenCorrect() { - int matches = runTest("(.*)", "text(.*)", Pattern.LITERAL); - assertTrue(matches > 0); - } - - @Test - public void givenRegex_whenMatchFailsWithoutMultilineFlag_thenCorrect() { - int matches = runTest("dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox"); - assertFalse(matches > 0); - } - - @Test - public void givenRegex_whenMatchesWithMultilineFlag_thenCorrect() { - int matches = runTest("dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox", Pattern.MULTILINE); - assertTrue(matches > 0); - } - - @Test - public void givenRegex_whenMatchesWithEmbeddedMultilineFlag_thenCorrect() { - int matches = runTest("(?m)dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox"); - assertTrue(matches > 0); - } - - @Test - public void givenMatch_whenGetsIndices_thenCorrect() { - Pattern pattern = Pattern.compile("dog"); - Matcher matcher = pattern.matcher("This dog is mine"); - matcher.find(); - assertEquals(5, matcher.start()); - assertEquals(8, matcher.end()); - } - - @Test - public void whenStudyMethodsWork_thenCorrect() { - Pattern pattern = Pattern.compile("dog"); - Matcher matcher = pattern.matcher("dogs are friendly"); - assertTrue(matcher.lookingAt()); - assertFalse(matcher.matches()); - - } - - @Test - public void whenMatchesStudyMethodWorks_thenCorrect() { - Pattern pattern = Pattern.compile("dog"); - Matcher matcher = pattern.matcher("dog"); - assertTrue(matcher.matches()); - - } - - @Test - public void whenReplaceFirstWorks_thenCorrect() { - Pattern pattern = Pattern.compile("dog"); - Matcher matcher = pattern.matcher("dogs are domestic animals, dogs are friendly"); - String newStr = matcher.replaceFirst("cat"); - assertEquals("cats are domestic animals, dogs are friendly", newStr); - - } - - @Test - public void whenReplaceAllWorks_thenCorrect() { - Pattern pattern = Pattern.compile("dog"); - Matcher matcher = pattern.matcher("dogs are domestic animals, dogs are friendly"); - String newStr = matcher.replaceAll("cat"); - assertEquals("cats are domestic animals, cats are friendly", newStr); - - } - - public synchronized static int runTest(String regex, String text) { - pattern = Pattern.compile(regex); - matcher = pattern.matcher(text); - int matches = 0; - while (matcher.find()) - matches++; - return matches; - } - - public synchronized static int runTest(String regex, String text, int flags) { - pattern = Pattern.compile(regex, flags); - matcher = pattern.matcher(text); - int matches = 0; - while (matcher.find()) - matches++; - return matches; - } -} From eb74e279dfbe65c247668d3280ba7877eb56d458 Mon Sep 17 00:00:00 2001 From: Paul Jervis Date: Sat, 11 Aug 2018 23:57:55 +0100 Subject: [PATCH 5/5] revert changes to RegexUnitTest --- .../baeldung/java/regex/RegexUnitTest.java | 501 ++++++++++++++++++ 1 file changed, 501 insertions(+) create mode 100644 core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java diff --git a/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java b/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java new file mode 100644 index 000000000000..e4ea55aae3e6 --- /dev/null +++ b/core-java/src/test/java/com/baeldung/java/regex/RegexUnitTest.java @@ -0,0 +1,501 @@ +package com.baeldung.java.regex; + +import static org.junit.Assert.*; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.junit.Test; + +public class RegexUnitTest { + private static Pattern pattern; + private static Matcher matcher; + + @Test + public void givenText_whenSimpleRegexMatches_thenCorrect() { + Pattern pattern = Pattern.compile("foo"); + Matcher matcher = pattern.matcher("foo"); + assertTrue(matcher.find()); + } + + @Test + public void givenText_whenSimpleRegexMatchesTwice_thenCorrect() { + Pattern pattern = Pattern.compile("foo"); + Matcher matcher = pattern.matcher("foofoo"); + int matches = 0; + while (matcher.find()) + matches++; + assertEquals(matches, 2); + + } + + @Test + public void givenText_whenMatchesWithDotMetach_thenCorrect() { + int matches = runTest(".", "foo"); + assertTrue(matches > 0); + } + + @Test + public void givenRepeatedText_whenMatchesOnceWithDotMetach_thenCorrect() { + int matches = runTest("foo.", "foofoo"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenORSet_whenMatchesAny_thenCorrect() { + int matches = runTest("[abc]", "b"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenORSet_whenMatchesAnyAndAll_thenCorrect() { + int matches = runTest("[abc]", "cab"); + assertTrue(matches > 0); + assertEquals(matches, 3); + } + + @Test + public void givenORSet_whenMatchesAllCombinations_thenCorrect() { + int matches = runTest("[bcr]at", "bat cat rat"); + assertTrue(matches > 0); + assertEquals(matches, 3); + } + + @Test + public void givenNORSet_whenMatchesNon_thenCorrect() { + int matches = runTest("[^abc]", "g"); + assertTrue(matches > 0); + } + + @Test + public void givenNORSet_whenMatchesAllExceptElements_thenCorrect() { + int matches = runTest("[^bcr]at", "sat mat eat"); + assertTrue(matches > 0); + } + + @Test + public void givenUpperCaseRange_whenMatchesUpperCase_thenCorrect() { + int matches = runTest("[A-Z]", "Two Uppercase alphabets 34 overall"); + assertTrue(matches > 0); + assertEquals(matches, 2); + } + + @Test + public void givenLowerCaseRange_whenMatchesLowerCase_thenCorrect() { + int matches = runTest("[a-z]", "Two Uppercase alphabets 34 overall"); + assertTrue(matches > 0); + assertEquals(matches, 26); + } + + @Test + public void givenBothLowerAndUpperCaseRange_whenMatchesAllLetters_thenCorrect() { + int matches = runTest("[a-zA-Z]", "Two Uppercase alphabets 34 overall"); + assertTrue(matches > 0); + assertEquals(matches, 28); + } + + @Test + public void givenNumberRange_whenMatchesAccurately_thenCorrect() { + int matches = runTest("[1-5]", "Two Uppercase alphabets 34 overall"); + assertTrue(matches > 0); + assertEquals(matches, 2); + } + + @Test + public void givenNumberRange_whenMatchesAccurately_thenCorrect2() { + int matches = runTest("[30-35]", "Two Uppercase alphabets 34 overall"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenTwoSets_whenMatchesUnion_thenCorrect() { + int matches = runTest("[1-3[7-9]]", "123456789"); + assertTrue(matches > 0); + assertEquals(matches, 6); + } + + @Test + public void givenTwoSets_whenMatchesIntersection_thenCorrect() { + int matches = runTest("[1-6&&[3-9]]", "123456789"); + assertTrue(matches > 0); + assertEquals(matches, 4); + } + + @Test + public void givenSetWithSubtraction_whenMatchesAccurately_thenCorrect() { + int matches = runTest("[0-9&&[^2468]]", "123456789"); + assertTrue(matches > 0); + assertEquals(matches, 5); + } + + @Test + public void givenDigits_whenMatches_thenCorrect() { + int matches = runTest("\\d", "123"); + assertTrue(matches > 0); + assertEquals(matches, 3); + } + + @Test + public void givenNonDigits_whenMatches_thenCorrect() { + int matches = runTest("\\D", "a6c"); + assertTrue(matches > 0); + assertEquals(matches, 2); + } + + @Test + public void givenWhiteSpace_whenMatches_thenCorrect() { + int matches = runTest("\\s", "a c"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenNonWhiteSpace_whenMatches_thenCorrect() { + int matches = runTest("\\S", "a c"); + assertTrue(matches > 0); + assertEquals(matches, 2); + } + + @Test + public void givenWordCharacter_whenMatches_thenCorrect() { + int matches = runTest("\\w", "hi!"); + assertTrue(matches > 0); + assertEquals(matches, 2); + } + + @Test + public void givenNonWordCharacter_whenMatches_thenCorrect() { + int matches = runTest("\\W", "hi!"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenZeroOrOneQuantifier_whenMatches_thenCorrect() { + int matches = runTest("\\a?", "hi"); + assertTrue(matches > 0); + assertEquals(matches, 3); + } + + @Test + public void givenZeroOrOneQuantifier_whenMatches_thenCorrect2() { + int matches = runTest("\\a{0,1}", "hi"); + assertTrue(matches > 0); + assertEquals(matches, 3); + } + + @Test + public void givenZeroOrManyQuantifier_whenMatches_thenCorrect() { + int matches = runTest("\\a*", "hi"); + assertTrue(matches > 0); + assertEquals(matches, 3); + } + + @Test + public void givenZeroOrManyQuantifier_whenMatches_thenCorrect2() { + int matches = runTest("\\a{0,}", "hi"); + assertTrue(matches > 0); + assertEquals(matches, 3); + } + + @Test + public void givenOneOrManyQuantifier_whenMatches_thenCorrect() { + int matches = runTest("\\a+", "hi"); + assertFalse(matches > 0); + } + + @Test + public void givenOneOrManyQuantifier_whenMatches_thenCorrect2() { + int matches = runTest("\\a{1,}", "hi"); + assertFalse(matches > 0); + } + + @Test + public void givenBraceQuantifier_whenMatches_thenCorrect() { + int matches = runTest("a{3}", "aaaaaa"); + assertTrue(matches > 0); + assertEquals(matches, 2); + } + + @Test + public void givenBraceQuantifier_whenFailsToMatch_thenCorrect() { + int matches = runTest("a{3}", "aa"); + assertFalse(matches > 0); + } + + @Test + public void givenBraceQuantifierWithRange_whenMatches_thenCorrect() { + int matches = runTest("a{2,3}", "aaaa"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenBraceQuantifierWithRange_whenMatchesLazily_thenCorrect() { + int matches = runTest("a{2,3}?", "aaaa"); + assertTrue(matches > 0); + assertEquals(matches, 2); + } + + @Test + public void givenCapturingGroup_whenMatches_thenCorrect() { + int matches = runTest("(\\d\\d)", "12"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenCapturingGroup_whenMatches_thenCorrect2() { + int matches = runTest("(\\d\\d)", "1212"); + assertTrue(matches > 0); + assertEquals(matches, 2); + } + + @Test + public void givenCapturingGroup_whenMatches_thenCorrect3() { + int matches = runTest("(\\d\\d)(\\d\\d)", "1212"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenCapturingGroup_whenMatchesWithBackReference_thenCorrect() { + int matches = runTest("(\\d\\d)\\1", "1212"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenCapturingGroup_whenMatchesWithBackReference_thenCorrect2() { + int matches = runTest("(\\d\\d)\\1\\1\\1", "12121212"); + assertTrue(matches > 0); + assertEquals(matches, 1); + } + + @Test + public void givenCapturingGroupAndWrongInput_whenMatchFailsWithBackReference_thenCorrect() { + int matches = runTest("(\\d\\d)\\1", "1213"); + assertFalse(matches > 0); + } + + @Test + public void givenText_whenMatchesAtBeginning_thenCorrect() { + int matches = runTest("^dog", "dogs are friendly"); + assertTrue(matches > 0); + } + + @Test + public void givenTextAndWrongInput_whenMatchFailsAtBeginning_thenCorrect() { + int matches = runTest("^dog", "are dogs are friendly?"); + assertFalse(matches > 0); + } + + @Test + public void givenText_whenMatchesAtEnd_thenCorrect() { + int matches = runTest("dog$", "Man's best friend is a dog"); + assertTrue(matches > 0); + } + + @Test + public void givenTextAndWrongInput_whenMatchFailsAtEnd_thenCorrect() { + int matches = runTest("dog$", "is a dog man's best friend?"); + assertFalse(matches > 0); + } + + @Test + public void givenText_whenMatchesAtWordBoundary_thenCorrect() { + int matches = runTest("\\bdog\\b", "a dog is friendly"); + assertTrue(matches > 0); + } + + @Test + public void givenText_whenMatchesAtWordBoundary_thenCorrect2() { + int matches = runTest("\\bdog\\b", "dog is man's best friend"); + assertTrue(matches > 0); + } + + @Test + public void givenWrongText_whenMatchFailsAtWordBoundary_thenCorrect() { + int matches = runTest("\\bdog\\b", "snoop dogg is a rapper"); + assertFalse(matches > 0); + } + + @Test + public void givenText_whenMatchesAtWordAndNonBoundary_thenCorrect() { + int matches = runTest("\\bdog\\B", "snoop dogg is a rapper"); + assertTrue(matches > 0); + } + + @Test + public void givenRegexWithoutCanonEq_whenMatchFailsOnEquivalentUnicode_thenCorrect() { + int matches = runTest("\u00E9", "\u0065\u0301"); + assertFalse(matches > 0); + } + + @Test + public void givenRegexWithCanonEq_whenMatchesOnEquivalentUnicode_thenCorrect() { + int matches = runTest("\u00E9", "\u0065\u0301", Pattern.CANON_EQ); + assertTrue(matches > 0); + } + + @Test + public void givenRegexWithDefaultMatcher_whenMatchFailsOnDifferentCases_thenCorrect() { + int matches = runTest("dog", "This is a Dog"); + assertFalse(matches > 0); + } + + @Test + public void givenRegexWithCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() { + int matches = runTest("dog", "This is a Dog", Pattern.CASE_INSENSITIVE); + assertTrue(matches > 0); + } + + @Test + public void givenRegexWithEmbeddedCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() { + int matches = runTest("(?i)dog", "This is a Dog"); + assertTrue(matches > 0); + } + + @Test + public void givenRegexWithComments_whenMatchFailsWithoutFlag_thenCorrect() { + int matches = runTest("dog$ #check for word dog at end of text", "This is a dog"); + assertFalse(matches > 0); + } + + @Test + public void givenRegexWithComments_whenMatchesWithFlag_thenCorrect() { + int matches = runTest("dog$ #check for word dog at end of text", "This is a dog", Pattern.COMMENTS); + assertTrue(matches > 0); + } + + @Test + public void givenRegexWithComments_whenMatchesWithEmbeddedFlag_thenCorrect() { + int matches = runTest("(?x)dog$ #check for word dog at end of text", "This is a dog"); + assertTrue(matches > 0); + } + + @Test + public void givenRegexWithLineTerminator_whenMatchFails_thenCorrect() { + Pattern pattern = Pattern.compile("(.*)"); + Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line"); + matcher.find(); + assertEquals("this is a text", matcher.group(1)); + } + + @Test + public void givenRegexWithLineTerminator_whenMatchesWithDotall_thenCorrect() { + Pattern pattern = Pattern.compile("(.*)", Pattern.DOTALL); + Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line"); + matcher.find(); + assertEquals("this is a text" + System.getProperty("line.separator") + " continued on another line", matcher.group(1)); + } + + @Test + public void givenRegexWithLineTerminator_whenMatchesWithEmbeddedDotall_thenCorrect() { + Pattern pattern = Pattern.compile("(?s)(.*)"); + Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line"); + matcher.find(); + assertEquals("this is a text" + System.getProperty("line.separator") + " continued on another line", matcher.group(1)); + } + + @Test + public void givenRegex_whenMatchesWithoutLiteralFlag_thenCorrect() { + int matches = runTest("(.*)", "text"); + assertTrue(matches > 0); + } + + @Test + public void givenRegex_whenMatchFailsWithLiteralFlag_thenCorrect() { + int matches = runTest("(.*)", "text", Pattern.LITERAL); + assertFalse(matches > 0); + } + + @Test + public void givenRegex_whenMatchesWithLiteralFlag_thenCorrect() { + int matches = runTest("(.*)", "text(.*)", Pattern.LITERAL); + assertTrue(matches > 0); + } + + @Test + public void givenRegex_whenMatchFailsWithoutMultilineFlag_thenCorrect() { + int matches = runTest("dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox"); + assertFalse(matches > 0); + } + + @Test + public void givenRegex_whenMatchesWithMultilineFlag_thenCorrect() { + int matches = runTest("dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox", Pattern.MULTILINE); + assertTrue(matches > 0); + } + + @Test + public void givenRegex_whenMatchesWithEmbeddedMultilineFlag_thenCorrect() { + int matches = runTest("(?m)dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox"); + assertTrue(matches > 0); + } + + @Test + public void givenMatch_whenGetsIndices_thenCorrect() { + Pattern pattern = Pattern.compile("dog"); + Matcher matcher = pattern.matcher("This dog is mine"); + matcher.find(); + assertEquals(5, matcher.start()); + assertEquals(8, matcher.end()); + } + + @Test + public void whenStudyMethodsWork_thenCorrect() { + Pattern pattern = Pattern.compile("dog"); + Matcher matcher = pattern.matcher("dogs are friendly"); + assertTrue(matcher.lookingAt()); + assertFalse(matcher.matches()); + + } + + @Test + public void whenMatchesStudyMethodWorks_thenCorrect() { + Pattern pattern = Pattern.compile("dog"); + Matcher matcher = pattern.matcher("dog"); + assertTrue(matcher.matches()); + + } + + @Test + public void whenReplaceFirstWorks_thenCorrect() { + Pattern pattern = Pattern.compile("dog"); + Matcher matcher = pattern.matcher("dogs are domestic animals, dogs are friendly"); + String newStr = matcher.replaceFirst("cat"); + assertEquals("cats are domestic animals, dogs are friendly", newStr); + + } + + @Test + public void whenReplaceAllWorks_thenCorrect() { + Pattern pattern = Pattern.compile("dog"); + Matcher matcher = pattern.matcher("dogs are domestic animals, dogs are friendly"); + String newStr = matcher.replaceAll("cat"); + assertEquals("cats are domestic animals, cats are friendly", newStr); + + } + + public synchronized static int runTest(String regex, String text) { + pattern = Pattern.compile(regex); + matcher = pattern.matcher(text); + int matches = 0; + while (matcher.find()) + matches++; + return matches; + } + + public synchronized static int runTest(String regex, String text, int flags) { + pattern = Pattern.compile(regex, flags); + matcher = pattern.matcher(text); + int matches = 0; + while (matcher.find()) + matches++; + return matches; + } +}