How to use ShouldContainCharSequenceOnlyOnce method of org.assertj.core.error.ShouldContainCharSequenceOnlyOnce class
Best Assertj code snippet using org.assertj.core.error.ShouldContainCharSequenceOnlyOnce.ShouldContainCharSequenceOnlyOnce
Source:Strings_assertContainsOnlyOnce_Test.java 
...11 * Copyright 2012-2019 the original author or authors.12 */13package org.assertj.core.internal.strings;14import org.assertj.core.api.Assertions;15import org.assertj.core.error.ShouldContainCharSequenceOnlyOnce;16import org.assertj.core.internal.ErrorMessages;17import org.assertj.core.internal.StringsBaseTest;18import org.assertj.core.test.TestData;19import org.assertj.core.util.FailureMessages;20import org.junit.jupiter.api.Test;21/**22 * Tests for <code>{@link Strings#assertContainsOnlyOnce(AssertionInfo, CharSequence, CharSequence)}</code>.23 */24public class Strings_assertContainsOnlyOnce_Test extends StringsBaseTest {25 @Test26 public void should_pass_if_actual_contains_given_string_only_once() {27 strings.assertContainsOnlyOnce(TestData.someInfo(), "Yoda", "Yo");28 }29 @Test30 public void should_fail_if_actual_contains_given_string_more_than_once() {31 Assertions.assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> strings.assertContainsOnlyOnce(someInfo(), "Yodayoda", "oda")).withMessage(ShouldContainCharSequenceOnlyOnce.shouldContainOnlyOnce("Yodayoda", "oda", 2).create());32 }33 @Test34 public void should_fail_if_actual_contains_sequence_only_once_but_in_different_case() {35 Assertions.assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> strings.assertContainsOnlyOnce(someInfo(), "Yoda", "yo")).withMessage(ShouldContainCharSequenceOnlyOnce.shouldContainOnlyOnce("Yoda", "yo", 0).create());36 }37 @Test38 public void should_fail_if_actual_does_not_contain_given_string() {39 Assertions.assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> strings.assertContainsOnlyOnce(someInfo(), "Yoda", "Luke")).withMessage(ShouldContainCharSequenceOnlyOnce.shouldContainOnlyOnce("Yoda", "Luke", 0).create());40 }41 @Test42 public void should_throw_error_if_sequence_is_null() {43 Assertions.assertThatNullPointerException().isThrownBy(() -> strings.assertContainsOnlyOnce(someInfo(), "Yoda", null)).withMessage(ErrorMessages.charSequenceToLookForIsNull());44 }45 @Test46 public void should_fail_if_actual_is_null() {47 Assertions.assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> strings.assertContainsOnlyOnce(someInfo(), null, "Yoda")).withMessage(FailureMessages.actualIsNull());48 }49 @Test50 public void should_pass_if_actual_contains_sequence_only_once_according_to_custom_comparison_strategy() {51 stringsWithCaseInsensitiveComparisonStrategy.assertContainsOnlyOnce(TestData.someInfo(), "Yoda", "Yo");52 stringsWithCaseInsensitiveComparisonStrategy.assertContainsOnlyOnce(TestData.someInfo(), "Yoda", "yo");53 stringsWithCaseInsensitiveComparisonStrategy.assertContainsOnlyOnce(TestData.someInfo(), "Yoda", "YO");54 }55 @Test56 public void should_fail_if_actual_does_not_contain_sequence_only_once_according_to_custom_comparison_strategy() {57 Assertions.assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> stringsWithCaseInsensitiveComparisonStrategy.assertContainsOnlyOnce(someInfo(), "Yoda", "Luke")).withMessage(ShouldContainCharSequenceOnlyOnce.shouldContainOnlyOnce("Yoda", "Luke", 0, comparisonStrategy).create());58 }59 @Test60 public void should_fail_if_actual_contains_sequence_several_times_according_to_custom_comparison_strategy() {61 Assertions.assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> stringsWithCaseInsensitiveComparisonStrategy.assertContainsOnlyOnce(someInfo(), "Yoda", "Luke")).withMessage(ShouldContainCharSequenceOnlyOnce.shouldContainOnlyOnce("Yoda", "Luke", 0, comparisonStrategy).create());62 }63}...
Source:ShouldContainCharSequenceOnlyOnce.java
...20 * @author Pauline Iogna21 * @author Joel Costigliola22 * @author Mikhail Mazursky23 */24public class ShouldContainCharSequenceOnlyOnce extends BasicErrorMessageFactory {25 /**26 * Creates a new <code>{@link ShouldContainCharSequenceOnlyOnce}</code>.27 * 28 * @param actual the actual value in the failed assertion.29 * @param sequence the String expected to be in {@code actual} only once.30 * @param occurrences the number of occurrences of sequence in actual.31 * @param comparisonStrategy the {@link ComparisonStrategy} used to evaluate assertion.32 * @return the created {@code ErrorMessageFactory}.33 */34 public static ErrorMessageFactory shouldContainOnlyOnce(CharSequence actual, CharSequence sequence, int occurrences,35 ComparisonStrategy comparisonStrategy) {36 if (occurrences == 0) return new ShouldContainCharSequenceOnlyOnce(actual, sequence, comparisonStrategy);37 return new ShouldContainCharSequenceOnlyOnce(actual, sequence, occurrences, comparisonStrategy);38 }39 /**40 * Creates a new <code>{@link ShouldContainCharSequenceOnlyOnce}</code>.41 * 42 * @param actual the actual value in the failed assertion.43 * @param sequence the String expected to be in {@code actual} only once.44 * @param occurrences the number of occurrences of sequence in actual.45 * @return the created {@code ErrorMessageFactory}.46 */47 public static ErrorMessageFactory shouldContainOnlyOnce(CharSequence actual, CharSequence sequence, int occurrences) {48 return shouldContainOnlyOnce(actual, sequence, occurrences, StandardComparisonStrategy.instance());49 }50 private ShouldContainCharSequenceOnlyOnce(CharSequence actual, CharSequence expected, int occurrences, ComparisonStrategy comparisonStrategy) {51 super("%nExpecting actual:%n %s%nto appear only once in:%n %s%nbut it appeared %s times %s", expected, actual,52 occurrences,53 comparisonStrategy);54 }55 private ShouldContainCharSequenceOnlyOnce(CharSequence actual, CharSequence expected, ComparisonStrategy comparisonStrategy) {56 super("%nExpecting actual:%n %s%nto appear only once in:%n %s%nbut it did not appear %s", expected, actual,57 comparisonStrategy);58 }59}...
ShouldContainCharSequenceOnlyOnce
Using AI Code Generation
1package org.assertj.core.error;2import org.assertj.core.internal.TestDescription;3import org.assertj.core.presentation.StandardRepresentation;4import org.junit.Test;5import static org.assertj.core.api.Assertions.assertThat;6import static org.assertj.core.error.ShouldContainCharSequenceOnlyOnce.shouldContainCharSequenceOnlyOnce;7import static org.assertj.core.util.Throwables.getStackTrace;8public class ShouldContainCharSequenceOnlyOnce_create_Test {9 public void should_create_error_message() {10 String error = shouldContainCharSequenceOnlyOnce("Yoda", "od", 2).create(new TestDescription("Test"), new StandardRepresentation());11 assertThat(error).isEqualTo(String.format("[Test] %n" +12 "but it was found 2 times"));13 }14}15package org.assertj.core.error;16import org.assertj.core.internal.TestDescription;17import org.assertj.core.presentation.StandardRepresentation;18import org.junit.Test;19import static org.assertj.core.api.Assertions.assertThat;20import static org.assertj.core.error.ShouldContainCharSequenceOnlyOnce.shouldContainCharSequenceOnlyOnce;21import static org.assertj.core.util.Throwables.getStackTrace;22public class ShouldContainCharSequenceOnlyOnce_create_Test {23 public void should_create_error_message() {24 String error = shouldContainCharSequenceOnlyOnce("Yoda", "od", 2).create(new TestDescription("Test"), new StandardRepresentation());25 assertThat(error).isEqualTo(String.format("[Test] %n" +26 "but it was found 2 times"));27 }28}
ShouldContainCharSequenceOnlyOnce
Using AI Code Generation
1package org.assertj.core.error;2import org.assertj.core.internal.TestDescription;3import org.assertj.core.presentation.StandardRepresentation;4import org.junit.Test;5import static org.assertj.core.api.Assertions.assertThat;6import static org.assertj.core.error.ShouldContainCharSequenceOnlyOnce.shouldContainCharSequenceOnlyOnce;7public class ShouldContainCharSequenceOnlyOnce_create_Test {8public void should_create_error_message() {9String message = shouldContainCharSequenceOnlyOnce("Yoda", "Yo", "od").create(new TestDescription("TEST"), new StandardRepresentation());10assertThat(message).isEqualTo(String.format("[TEST] %n" +11"but it was found 2 times"));12}13}14package org.assertj.core.error;15import java.util.List;16import org.assertj.core.api.Condition;17import org.assertj.core.internal.TestDescription;18import org.assertj.core.presentation.StandardRepresentation;19import org.junit.Test;20import static org.assertj.core.api.Assertions.assertThat;21import static org.assertj.core.error.ShouldContainCharSequenceOnlyOnce.shouldContainCharSequenceOnlyOnce;22import static org.assertj.core.util.Lists.newArrayList;23public class ShouldContainCharSequenceOnlyOnce_create_Test {24public void should_create_error_message() {25String message = shouldContainCharSequenceOnlyOnce("Yoda", newArrayList("Yo", "od"), new Condition<Object>("custom condition") {26public boolean matches(Object value) {27return false;28}29}).create(new TestDescription("TEST"), new StandardRepresentation());30assertThat(message).isEqualTo(String.format("[TEST] %n" +31"when using custom condition"));32}33}34}35package org.assertj.core.error;36import java.util.List;37import org.assertj.core.api.Condition;38import org.assertj.core.internal.TestDescription;39import org.assertj.core.presentation.StandardRepresentation;40import org.junit.Test;41import static org.assertj
ShouldContainCharSequenceOnlyOnce
Using AI Code Generation
1package org.assertj.core.error;2public class ShouldContainCharSequenceOnlyOnce {3 public static ErrorMessageFactory shouldContainCharSequenceOnlyOnce(CharSequence actual, CharSequence sequence) {4 return new ShouldContainCharSequenceOnlyOnce(actual, sequence);5 }6 private ShouldContainCharSequenceOnlyOnce(CharSequence actual, CharSequence sequence) {7 super("%nExpecting:%n <%s>%n to contain only once:%n <%s>%n but it was found:%n <%s> times", actual, sequence, countOccurrences(actual, sequence));8 }9}10package org.assertj.core.error;11public class ShouldContainCharSequenceOnlyOnce extends BasicErrorMessageFactory {12 private ShouldContainCharSequenceOnlyOnce(CharSequence actual, CharSequence sequence) {13 super("%nExpecting:%n <%s>%n to contain only once:%n <%s>%n but it was found:%n <%s> times", actual, sequence, countOccurrences(actual, sequence));14 }15}16package org.assertj.core.error;17public class ShouldContainCharSequenceOnlyOnce extends BasicErrorMessageFactory {18 private ShouldContainCharSequenceOnlyOnce(CharSequence actual, CharSequence sequence) {19 super("%nExpecting:%n <%s>%n to contain only once:%n <%s>%n but it was found:%n <%s> times", actual, sequence, countOccurrences(actual, sequence));20 }21}22package org.assertj.core.error;23public class ShouldContainCharSequenceOnlyOnce extends BasicErrorMessageFactory {24 private ShouldContainCharSequenceOnlyOnce(CharSequence actual, CharSequence sequence) {25 super("%nExpecting:%n <%s>%n to contain only once:%n <%s>%n but it was found:%n <%s> times", actual, sequence, countOccurrences(actual, sequence));26 }27}28package org.assertj.core.error;29public class ShouldContainCharSequenceOnlyOnce extends BasicErrorMessageFactory {30 private ShouldContainCharSequenceOnlyOnce(CharSequence actual, CharSequence sequence) {31 super("%nExpecting:%n <%s>%n to contain only once:%n
ShouldContainCharSequenceOnlyOnce
Using AI Code Generation
1import org.assertj.core.api.Assertions;2import org.assertj.core.error.ShouldContainCharSequenceOnlyOnce;3public class ShouldContainCharSequenceOnlyOnceExample {4 public static void main(String[] args) {5 Assertions.assertThatThrownBy(() -> {6 throw new AssertionError("Assertion error message");7 }).isInstanceOf(AssertionError.class)8 .hasMessage(ShouldContainCharSequenceOnlyOnce.shouldContainCharSequenceOnlyOnce("my string", "my", 1).create());9 }10}11import org.assertj.core.api.Assertions;12import org.assertj.core.error.ShouldContainCharSequenceOnlyOnce;13public class ShouldContainCharSequenceOnlyOnceExample {14 public static void main(String[] args) {15 Assertions.assertThatThrownBy(() -> {16 throw new AssertionError("Assertion error message");17 }).isInstanceOf(AssertionError.class)18 .hasMessage(ShouldContainCharSequenceOnlyOnce.shouldContainCharSequenceOnlyOnce("my string", "my", 1).create());19 }20}
ShouldContainCharSequenceOnlyOnce
Using AI Code Generation
1import org.assertj.core.error.ShouldContainCharSequenceOnlyOnce;2import org.assertj.core.description.Description;3import org.assertj.core.presentation.StandardRepresentation;4import org.assertj.core.util.CaseInsensitiveStringComparator;5import org.assertj.core.util.VisibleForTesting;6import java.util.List;7public class ShouldContainCharSequenceOnlyOnceExample {8 public static void main(String[] args) {9 Description description = new Description("Test");10 ShouldContainCharSequenceOnlyOnce shouldContainCharSequenceOnlyOnce = new ShouldContainCharSequenceOnlyOnce(description, new StandardRepresentation(), "Yoda", List.of("Luke", "Yoda", "Leia", "Yoda"));11 System.out.println(shouldContainCharSequenceOnlyOnce.getMessage());12 }13}
ShouldContainCharSequenceOnlyOnce
Using AI Code Generation
1import org.assertj.core.error.ShouldContainCharSequenceOnlyOnce;2import org.assertj.core.api.Assertions;3import org.assertj.core.api.AssertionInfo;4public class ShouldContainCharSequenceOnlyOnceExample {5 public static void main(String[] args) {6 AssertionInfo info = new AssertionInfo();7 Throwable error = ShouldContainCharSequenceOnlyOnce.shouldContainCharSequenceOnlyOnce("Yoda", "Yoda", 2);8 System.out.println(error.getMessage());9 }10}
ShouldContainCharSequenceOnlyOnce
Using AI Code Generation
1public class Test {2 public static void main(String[] args) {3 String str = "hello";4 char[] c = {'h', 'e', 'l', 'l', 'o'};5 assertThatThrownBy(() -> assertThat(str).containsOnlyOnce(c))6 .isInstanceOf(AssertionError.class)7 .hasMessage(ShouldContainCharSequenceOnlyOnce.shouldContainCharSequenceOnlyOnce(str, c, 2).create());8 }9}
ShouldContainCharSequenceOnlyOnce
Using AI Code Generation
1public class AssertJErrorHandling {2 public static void main(String[] args) {3 String str = "I love Java";4 String subStr = "Java";5 assertThat(str).overridingErrorMessage("String %s should contain %s only once.", str, subStr).containsOnlyOnce(subStr);6 }7}8at org.assertj.core.api.AbstractStringAssert.containsOnlyOnce(AbstractStringAssert.java:153)9at AssertJErrorHandling.main(AssertJErrorHandling.java:9)
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Assertj automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used method in ShouldContainCharSequenceOnlyOnce
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
