hope.kola.contract.assertj.bridge.StringAssert Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of it-kola-contract Show documentation
null
There is a newer version: 1.1.2-RELEASE
package hope.kola.contract.assertj.bridge;

import com.squareup.javapoet.ClassName;
import hope.kola.contract.assertj.model.DynamicProperty;
import hope.kola.contract.assertj.model.PrimitiveType;
import java.io.File;
import java.util.function.Consumer;

/** {@link org.assertj.core.api.AbstractStringAssert} */
public class StringAssert extends AssertThat {
  @Override
  public PrimitiveType primitiveType() {
    return PrimitiveType.STRING;
  }

  @Override
  public ClassName assertJClass() {
    return ClassName.get("org.assertj.core.api", "AbstractStringAssert");
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isLessThan} */
  public StringAssert isLessThan(String other) {
    segment("isLessThan").argument(DynamicProperty.newString(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isLessThanOrEqualTo} */
  public StringAssert isLessThanOrEqualTo(String other) {
    segment("isLessThanOrEqualTo").argument(DynamicProperty.newString(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isGreaterThan} */
  public StringAssert isGreaterThan(String other) {
    segment("isGreaterThan").argument(DynamicProperty.newString(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isGreaterThanOrEqualTo} */
  public StringAssert isGreaterThanOrEqualTo(String other) {
    segment("isGreaterThanOrEqualTo").argument(DynamicProperty.newString(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isBetween} */
  public StringAssert isBetween(String startInclusive, String endInclusive) {
    segment("isBetween")
        .argument(DynamicProperty.newString(startInclusive))
        .argument(DynamicProperty.newString(endInclusive));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isStrictlyBetween} */
  public StringAssert isStrictlyBetween(String startExclusive, String endExclusive) {
    segment("isStrictlyBetween")
        .argument(DynamicProperty.newString(startExclusive))
        .argument(DynamicProperty.newString(endExclusive));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isBase64} */
  public StringAssert isBase64() {
    segment("isBase64");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isEqualTo} */
  public StringAssert isEqualTo(String expectedStringTemplate, Object[] args) {
    segment("isEqualTo").argument(DynamicProperty.newString(expectedStringTemplate));
    // TODO add your logic
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isEqualTo} */
  public StringAssert isEqualTo(String expected) {
    segment("isEqualTo").argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isNullOrEmpty} */
  public StringAssert isNullOrEmpty() {
    segment("isNullOrEmpty");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isEmpty} */
  public StringAssert isEmpty() {
    segment("isEmpty");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isNotEmpty} */
  public StringAssert isNotEmpty() {
    segment("isNotEmpty");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isBlank} */
  public StringAssert isBlank() {
    segment("isBlank");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isNotBlank} */
  public StringAssert isNotBlank() {
    segment("isNotBlank");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsWhitespaces} */
  public StringAssert containsWhitespaces() {
    segment("containsWhitespaces");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsOnlyWhitespaces} */
  public StringAssert containsOnlyWhitespaces() {
    segment("containsOnlyWhitespaces");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotContainAnyWhitespaces} */
  public StringAssert doesNotContainAnyWhitespaces() {
    segment("doesNotContainAnyWhitespaces");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotContainOnlyWhitespaces} */
  public StringAssert doesNotContainOnlyWhitespaces() {
    segment("doesNotContainOnlyWhitespaces");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isJavaBlank} */
  public StringAssert isJavaBlank() {
    segment("isJavaBlank");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isNotJavaBlank} */
  public StringAssert isNotJavaBlank() {
    segment("isNotJavaBlank");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#hasSize} */
  public StringAssert hasSize(Integer expected) {
    segment("hasSize").argument(DynamicProperty.newInteger(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#hasSizeLessThan} */
  public StringAssert hasSizeLessThan(Integer expected) {
    segment("hasSizeLessThan").argument(DynamicProperty.newInteger(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#hasSizeLessThanOrEqualTo} */
  public StringAssert hasSizeLessThanOrEqualTo(Integer expected) {
    segment("hasSizeLessThanOrEqualTo").argument(DynamicProperty.newInteger(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#hasSizeGreaterThan} */
  public StringAssert hasSizeGreaterThan(Integer expected) {
    segment("hasSizeGreaterThan").argument(DynamicProperty.newInteger(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#hasSizeGreaterThanOrEqualTo} */
  public StringAssert hasSizeGreaterThanOrEqualTo(Integer expected) {
    segment("hasSizeGreaterThanOrEqualTo").argument(DynamicProperty.newInteger(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#hasSizeBetween} */
  public StringAssert hasSizeBetween(Integer lowerBoundary, Integer higherBoundary) {
    segment("hasSizeBetween")
        .argument(DynamicProperty.newInteger(lowerBoundary))
        .argument(DynamicProperty.newInteger(higherBoundary));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#hasLineCount} */
  public StringAssert hasLineCount(Integer expectedLineCount) {
    segment("hasLineCount").argument(DynamicProperty.newInteger(expectedLineCount));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#hasSameSizeAs} */
  public StringAssert hasSameSizeAs(String other) {
    segment("hasSameSizeAs").argument(DynamicProperty.newString(other));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isEqualToIgnoringCase} */
  public StringAssert isEqualToIgnoringCase(String expected) {
    segment("isEqualToIgnoringCase").argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isNotEqualToIgnoringCase} */
  public StringAssert isNotEqualToIgnoringCase(String expected) {
    segment("isNotEqualToIgnoringCase").argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsOnlyDigits} */
  public StringAssert containsOnlyDigits() {
    segment("containsOnlyDigits");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsOnlyOnce} */
  public StringAssert containsOnlyOnce(String sequence) {
    segment("containsOnlyOnce").argument(DynamicProperty.newString(sequence));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#contains} */
  public StringAssert contains(String[] values) {
    segment("contains").argument(DynamicProperty.newStringArray(values));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsAnyOf} */
  public StringAssert containsAnyOf(String[] values) {
    segment("containsAnyOf").argument(DynamicProperty.newStringArray(values));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsSequence} */
  public StringAssert containsSequence(String[] values) {
    segment("containsSequence").argument(DynamicProperty.newStringArray(values));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsSubsequence} */
  public StringAssert containsSubsequence(String[] values) {
    segment("containsSubsequence").argument(DynamicProperty.newStringArray(values));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsIgnoringCase} */
  public StringAssert containsIgnoringCase(String sequence) {
    segment("containsIgnoringCase").argument(DynamicProperty.newString(sequence));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsIgnoringWhitespaces} */
  public StringAssert containsIgnoringWhitespaces(String[] values) {
    segment("containsIgnoringWhitespaces").argument(DynamicProperty.newStringArray(values));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsIgnoringNewLines} */
  public StringAssert containsIgnoringNewLines(String[] values) {
    segment("containsIgnoringNewLines").argument(DynamicProperty.newStringArray(values));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotContain} */
  public StringAssert doesNotContain(String[] values) {
    segment("doesNotContain").argument(DynamicProperty.newStringArray(values));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotContainIgnoringCase} */
  public StringAssert doesNotContainIgnoringCase(String[] values) {
    segment("doesNotContainIgnoringCase").argument(DynamicProperty.newStringArray(values));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotContainPattern} */
  public StringAssert doesNotContainPattern(String pattern) {
    segment("doesNotContainPattern").argument(DynamicProperty.newString(pattern));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#startsWith} */
  public StringAssert startsWith(String prefix) {
    segment("startsWith").argument(DynamicProperty.newString(prefix));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#startsWithIgnoringCase} */
  public StringAssert startsWithIgnoringCase(String prefix) {
    segment("startsWithIgnoringCase").argument(DynamicProperty.newString(prefix));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotStartWith} */
  public StringAssert doesNotStartWith(String prefix) {
    segment("doesNotStartWith").argument(DynamicProperty.newString(prefix));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotStartWithIgnoringCase} */
  public StringAssert doesNotStartWithIgnoringCase(String prefix) {
    segment("doesNotStartWithIgnoringCase").argument(DynamicProperty.newString(prefix));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#endsWith} */
  public StringAssert endsWith(String suffix) {
    segment("endsWith").argument(DynamicProperty.newString(suffix));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#endsWithIgnoringCase} */
  public StringAssert endsWithIgnoringCase(String suffix) {
    segment("endsWithIgnoringCase").argument(DynamicProperty.newString(suffix));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotEndWith} */
  public StringAssert doesNotEndWith(String suffix) {
    segment("doesNotEndWith").argument(DynamicProperty.newString(suffix));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotEndWithIgnoringCase} */
  public StringAssert doesNotEndWithIgnoringCase(String suffix) {
    segment("doesNotEndWithIgnoringCase").argument(DynamicProperty.newString(suffix));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#doesNotMatch} */
  public StringAssert doesNotMatch(String regex) {
    segment("doesNotMatch").argument(DynamicProperty.newString(regex));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isXmlEqualTo} */
  public StringAssert isXmlEqualTo(String expectedXml) {
    segment("isXmlEqualTo").argument(DynamicProperty.newString(expectedXml));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isXmlEqualToContentOf} */
  public StringAssert isXmlEqualToContentOf(File xmlFile) {
    // TODO add your logic
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isEqualToIgnoringWhitespace} */
  public StringAssert isEqualToIgnoringWhitespace(String expected) {
    segment("isEqualToIgnoringWhitespace").argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isNotEqualToIgnoringWhitespace} */
  public StringAssert isNotEqualToIgnoringWhitespace(String expected) {
    segment("isNotEqualToIgnoringWhitespace").argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isEqualToNormalizingWhitespace} */
  public StringAssert isEqualToNormalizingWhitespace(String expected) {
    segment("isEqualToNormalizingWhitespace").argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isNotEqualToNormalizingWhitespace} */
  public StringAssert isNotEqualToNormalizingWhitespace(String expected) {
    segment("isNotEqualToNormalizingWhitespace").argument(DynamicProperty.newString(expected));
    return this;
  }

  /**
   * {@link org.assertj.core.api.AbstractStringAssert#isEqualToNormalizingPunctuationAndWhitespace}
   */
  public StringAssert isEqualToNormalizingPunctuationAndWhitespace(String expected) {
    segment("isEqualToNormalizingPunctuationAndWhitespace")
        .argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isSubstringOf} */
  public StringAssert isSubstringOf(String sequence) {
    segment("isSubstringOf").argument(DynamicProperty.newString(sequence));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsPattern} */
  public StringAssert containsPattern(String regex) {
    segment("containsPattern").argument(DynamicProperty.newString(regex));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#containsPatternSatisfying} */
  public StringAssert containsPatternSatisfying(String regex, Consumer matchSatisfies) {
    segment("containsPatternSatisfying").argument(DynamicProperty.newString(regex));
    // TODO add your logic
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isEqualToNormalizingNewlines} */
  public StringAssert isEqualToNormalizingNewlines(String expected) {
    segment("isEqualToNormalizingNewlines").argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isEqualToIgnoringNewLines} */
  public StringAssert isEqualToIgnoringNewLines(String expected) {
    segment("isEqualToIgnoringNewLines").argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isLowerCase} */
  public StringAssert isLowerCase() {
    segment("isLowerCase");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isMixedCase} */
  public StringAssert isMixedCase() {
    segment("isMixedCase");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isUpperCase} */
  public StringAssert isUpperCase() {
    segment("isUpperCase");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isEqualToNormalizingUnicode} */
  public StringAssert isEqualToNormalizingUnicode(String expected) {
    segment("isEqualToNormalizingUnicode").argument(DynamicProperty.newString(expected));
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isAlphabetic} */
  public StringAssert isAlphabetic() {
    segment("isAlphabetic");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isAlphanumeric} */
  public StringAssert isAlphanumeric() {
    segment("isAlphanumeric");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isASCII} */
  public StringAssert isASCII() {
    segment("isASCII");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isHexadecimal} */
  public StringAssert isHexadecimal() {
    segment("isHexadecimal");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isPrintable} */
  public StringAssert isPrintable() {
    segment("isPrintable");
    return this;
  }

  /** {@link org.assertj.core.api.AbstractStringAssert#isVisible} */
  public StringAssert isVisible() {
    segment("isVisible");
    return this;
  }
}