001 /* 002 * Created on Dec 22, 2010 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with 005 * the License. You may obtain a copy of the License at 006 * 007 * http://www.apache.org/licenses/LICENSE-2.0 008 * 009 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on 010 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the 011 * specific language governing permissions and limitations under the License. 012 * 013 * Copyright @2010-2011 the original author or authors. 014 */ 015 package org.fest.assertions.api; 016 017 import java.util.Comparator; 018 import java.util.regex.Pattern; 019 import java.util.regex.PatternSyntaxException; 020 021 import org.fest.assertions.core.EnumerableAssert; 022 import org.fest.assertions.internal.Strings; 023 import org.fest.util.ComparatorBasedComparisonStrategy; 024 import org.fest.util.VisibleForTesting; 025 026 /** 027 * Assertion methods for {@code String}s. 028 * <p> 029 * To create a new instance of this class, invoke <code>{@link Assertions#assertThat(String)}</code>. 030 * </p> 031 * 032 * @author Yvonne Wang 033 * @author David DIDIER 034 * @author Alex Ruiz 035 * @author Joel Costigliola 036 */ 037 public class StringAssert extends AbstractAssert<StringAssert, String> implements EnumerableAssert<StringAssert> { 038 039 @VisibleForTesting Strings strings = Strings.instance(); 040 041 protected StringAssert(String actual) { 042 super(actual, StringAssert.class); 043 } 044 045 /** {@inheritDoc} */ 046 public void isNullOrEmpty() { 047 strings.assertNullOrEmpty(info, actual); 048 } 049 050 /** {@inheritDoc} */ 051 public void isEmpty() { 052 strings.assertEmpty(info, actual); 053 } 054 055 /** {@inheritDoc} */ 056 public StringAssert isNotEmpty() { 057 strings.assertNotEmpty(info, actual); 058 return this; 059 } 060 061 /** {@inheritDoc} */ 062 public StringAssert hasSize(int expected) { 063 strings.assertHasSize(info, actual, expected); 064 return this; 065 } 066 067 /** 068 * Verifies that the actual {@code String} is equal to the given one, ignoring case considerations. 069 * @param expected the given {@code String} to compare the actual {@code String} to. 070 * @return {@code this} assertion object. 071 * @throws AssertionError if the actual {@code String} is not equal to the given one. 072 */ 073 public StringAssert isEqualToIgnoringCase(String expected) { 074 strings.assertEqualsIgnoringCase(info, actual, expected); 075 return this; 076 } 077 078 /** 079 * Verifies that the actual {@code String} contains the given sequence. 080 * @param sequence the sequence to search for. 081 * @return {@code this} assertion object. 082 * @throws NullPointerException if the given sequence is {@code null}. 083 * @throws AssertionError if the actual {@code String} is {@code null}. 084 * @throws AssertionError if the actual {@code String} does not contain the given one. 085 */ 086 public StringAssert contains(String sequence) { 087 strings.assertContains(info, actual, sequence); 088 return this; 089 } 090 091 /** 092 * Verifies that the actual {@code String} contains the given sequence, ignoring case considerations. 093 * @param sequence the sequence to search for. 094 * @return {@code this} assertion object. 095 * @throws NullPointerException if the given sequence is {@code null}. 096 * @throws AssertionError if the actual {@code String} is {@code null}. 097 * @throws AssertionError if the actual {@code String} does not contain the given one. 098 */ 099 public StringAssert containsIgnoringCase(String sequence) { 100 strings.assertContainsIgnoringCase(info, actual, sequence); 101 return this; 102 } 103 104 /** 105 * Verifies that the actual {@code String} does not contain the given sequence. 106 * @param sequence the sequence to search for. 107 * @return {@code this} assertion object. 108 * @throws NullPointerException if the given sequence is {@code null}. 109 * @throws AssertionError if the actual {@code String} is {@code null}. 110 * @throws AssertionError if the actual {@code String} contains the given one. 111 */ 112 public StringAssert doesNotContain(String sequence) { 113 strings.assertDoesNotContain(info, actual, sequence); 114 return this; 115 } 116 117 /** 118 * Verifies that the actual {@code String} starts with the given prefix. 119 * @param prefix the given prefix. 120 * @return {@code this} assertion object. 121 * @throws NullPointerException if the given prefix is {@code null}. 122 * @throws AssertionError if the actual {@code String} is {@code null}. 123 * @throws AssertionError if the actual {@code String} does not start with the given prefix. 124 */ 125 public StringAssert startsWith(String prefix) { 126 strings.assertStartsWith(info, actual, prefix); 127 return this; 128 } 129 130 /** 131 * Verifies that the actual {@code String} ends with the given suffix. 132 * @param suffix the given suffix. 133 * @return {@code this} assertion object. 134 * @throws NullPointerException if the given suffix is {@code null}. 135 * @throws AssertionError if the actual {@code String} is {@code null}. 136 * @throws AssertionError if the actual {@code String} does not end with the given suffix. 137 */ 138 public StringAssert endsWith(String suffix) { 139 strings.assertEndsWith(info, actual, suffix); 140 return this; 141 } 142 143 /** 144 * Verifies that the actual {@code String} matches the given regular expression. 145 * @param regex the regular expression to which the actual {@code String} is to be matched. 146 * @return {@code this} assertion object. 147 * @throws NullPointerException if the given pattern is {@code null}. 148 * @throws PatternSyntaxException if the regular expression's syntax is invalid. 149 * @throws AssertionError if the actual {@code String} is {@code null}. 150 * @throws AssertionError if the actual {@code String} does not match the given regular expression. 151 */ 152 public StringAssert matches(String regex) { 153 strings.assertMatches(info, actual, regex); 154 return this; 155 } 156 157 /** 158 * Verifies that the actual {@code String} does not match the given regular expression. 159 * @param regex the regular expression to which the actual {@code String} is to be matched. 160 * @return {@code this} assertion object. 161 * @throws NullPointerException if the given pattern is {@code null}. 162 * @throws PatternSyntaxException if the regular expression's syntax is invalid. 163 * @throws AssertionError if the actual {@code String} is {@code null}. 164 * @throws AssertionError if the actual {@code String} matches the given regular expression. 165 */ 166 public StringAssert doesNotMatch(String regex) { 167 strings.assertDoesNotMatch(info, actual, regex); 168 return this; 169 } 170 171 /** 172 * Verifies that the actual {@code String} matches the given regular expression. 173 * @param pattern the regular expression to which the actual {@code String} is to be matched. 174 * @return {@code this} assertion object. 175 * @throws NullPointerException if the given pattern is {@code null}. 176 * @throws AssertionError if the actual {@code String} is {@code null}. 177 * @throws AssertionError if the actual {@code String} does not match the given regular expression. 178 */ 179 public StringAssert matches(Pattern pattern) { 180 strings.assertMatches(info, actual, pattern); 181 return this; 182 } 183 184 /** 185 * Verifies that the actual {@code String} does not match the given regular expression. 186 * @param pattern the regular expression to which the actual {@code String} is to be matched. 187 * @return {@code this} assertion object. 188 * @throws NullPointerException if the given pattern is {@code null}. 189 * @throws AssertionError if the actual {@code String} does not match the given regular expression. 190 */ 191 public StringAssert doesNotMatch(Pattern pattern) { 192 strings.assertDoesNotMatch(info, actual, pattern); 193 return this; 194 } 195 196 @Override 197 public StringAssert usingComparator(Comparator<?> customComparator) { 198 super.usingComparator(customComparator); 199 this.strings = new Strings(new ComparatorBasedComparisonStrategy(customComparator)); 200 return myself; 201 } 202 203 @Override 204 public StringAssert usingDefaultComparator() { 205 super.usingDefaultComparator(); 206 this.strings = Strings.instance(); 207 return myself; 208 } 209 }