001 /* 002 * Created on Dec 26, 2006 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 005 * in compliance with 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 010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 011 * or implied. See the License for the specific language governing permissions and limitations under 012 * the License. 013 * 014 * Copyright @2006-2009 the original author or authors. 015 */ 016 package org.fest.assertions; 017 018 import static org.fest.assertions.Formatting.inBrackets; 019 import static org.fest.util.Strings.concat; 020 021 import org.fest.util.Strings; 022 023 /** 024 * Understands assertion methods for <code>String</code>s. To create a new instance of this class use the 025 * method <code>{@link Assertions#assertThat(String)}</code>. 026 * 027 * @author Yvonne Wang 028 * @author David DIDIER 029 */ 030 public class StringAssert extends GroupAssert<String> { 031 032 /** 033 * Creates a new </code>{@link StringAssert}</code>. 034 * @param actual the target to verify. 035 */ 036 protected StringAssert(String actual) { 037 super(actual); 038 } 039 040 /** {@inheritDoc} */ 041 public StringAssert as(String description) { 042 description(description); 043 return this; 044 } 045 046 /** {@inheritDoc} */ 047 public StringAssert describedAs(String description) { 048 return as(description); 049 } 050 051 /** {@inheritDoc} */ 052 public StringAssert as(Description description) { 053 description(description); 054 return this; 055 } 056 057 /** {@inheritDoc} */ 058 public StringAssert describedAs(Description description) { 059 return as(description); 060 } 061 062 /** 063 * Verifies that the actual <code>String</code> satisfies the given condition. 064 * @param condition the given condition. 065 * @return this assertion object. 066 * @throws NullPointerException if the given condition is <code>null</code>. 067 * @throws AssertionError if the actual <code>String</code> does not satisfy the given condition. 068 * @see #is(Condition) 069 */ 070 public StringAssert satisfies(Condition<String> condition) { 071 assertSatisfies(condition); 072 return this; 073 } 074 075 /** 076 * Verifies that the actual <code>String</code> does not satisfy the given condition. 077 * @param condition the given condition. 078 * @return this assertion object. 079 * @throws NullPointerException if the given condition is <code>null</code>. 080 * @throws AssertionError if the actual <code>String</code> satisfies the given condition. 081 * @see #isNot(Condition) 082 */ 083 public StringAssert doesNotSatisfy(Condition<String> condition) { 084 assertDoesNotSatisfy(condition); 085 return this; 086 } 087 088 /** 089 * Alias for <code>{@link #satisfies(Condition)}</code>. 090 * @param condition the given condition. 091 * @return this assertion object. 092 * @throws NullPointerException if the given condition is <code>null</code>. 093 * @throws AssertionError if the actual <code>String</code> does not satisfy the given condition. 094 * @since 1.2 095 */ 096 public StringAssert is(Condition<String> condition) { 097 assertIs(condition); 098 return this; 099 } 100 101 /** 102 * Alias for <code>{@link #doesNotSatisfy(Condition)}</code>. 103 * @param condition the given condition. 104 * @return this assertion object. 105 * @throws NullPointerException if the given condition is <code>null</code>. 106 * @throws AssertionError if the actual <code>String</code> satisfies the given condition. 107 * @since 1.2 108 */ 109 public StringAssert isNot(Condition<String> condition) { 110 assertIsNot(condition); 111 return this; 112 } 113 114 /** 115 * Verifies that the actual <code>String</code> is empty (not <code>null</code> with zero characters.) 116 * @throws AssertionError if the actual <code>String</code> is <code>null</code>. 117 * @throws AssertionError if the actual <code>String</code> is not empty. 118 */ 119 public void isEmpty() { 120 isNotNull(); 121 if (Strings.isEmpty(actual)) return; 122 failIfCustomMessageIsSet(); 123 fail(concat("expecting empty String but was:", inBrackets(actual))); 124 } 125 126 /** 127 * Verifies that the actual <code>String</code> is <code>null</code> or empty. 128 * @throws AssertionError if the actual <code>String</code> is not <code>null</code> or not empty. 129 */ 130 public final void isNullOrEmpty() { 131 if (Strings.isEmpty(actual)) return; 132 failIfCustomMessageIsSet(); 133 fail(concat("expecting a null or empty String, but was:", inBrackets(actual))); 134 } 135 136 /** 137 * Verifies that the actual <code>String</code> contains at least on character. 138 * @return this assertion object. 139 * @throws AssertionError if the actual <code>String</code> is <code>null</code>. 140 * @throws AssertionError if the actual <code>String</code> is <code>null</code> or empty. 141 */ 142 public StringAssert isNotEmpty() { 143 isNotNull(); 144 if (!Strings.isEmpty(actual)) return this; 145 failIfCustomMessageIsSet(); 146 throw failure(concat("expecting a non-empty String, but it was empty")); 147 } 148 149 /** 150 * Verifies that the actual <code>String</code> is equal to the given one. 151 * @param expected the given <code>String</code> to compare the actual <code>String</code> to. 152 * @return this assertion object. 153 * @throws AssertionError if the actual <code>String</code> is not equal to the given one. 154 */ 155 public StringAssert isEqualTo(String expected) { 156 assertEqualTo(expected); 157 return this; 158 } 159 160 /** 161 * Verifies that the actual <code>String</code> is not equal to the given one. 162 * @param other the given <code>String</code> to compare the actual <code>String</code> to. 163 * @return this assertion object. 164 * @throws AssertionError if the actual <code>String</code> is equal to the given one. 165 */ 166 public StringAssert isNotEqualTo(String other) { 167 assertNotEqualTo(other); 168 return this; 169 } 170 171 /** 172 * Verifies that the actual <code>String</code> is not <code>null</code>. 173 * @return this assertion object. 174 * @throws AssertionError if the actual <code>String</code> is <code>null</code>. 175 */ 176 public StringAssert isNotNull() { 177 assertNotNull(); 178 return this; 179 } 180 181 /** 182 * Verifies that the actual <code>String</code> is not the same as the given one. 183 * @param other the given <code>String</code> to compare the actual <code>String</code> to. 184 * @return this assertion object. 185 * @throws AssertionError if the actual <code>String</code> is the same as the given one. 186 */ 187 public StringAssert isNotSameAs(String other) { 188 assertNotSameAs(other); 189 return this; 190 } 191 192 /** 193 * Verifies that the actual <code>String</code> is the same as the given one. 194 * @param expected the given <code>String</code> to compare the actual <code>String</code> to. 195 * @return this assertion object. 196 * @throws AssertionError if the actual <code>String</code> is not the same as the given one. 197 */ 198 public StringAssert isSameAs(String expected) { 199 assertSameAs(expected); 200 return this; 201 } 202 203 /** 204 * Verifies that the number of characters in the actual <code>String</code> is equal to the given one. 205 * @param expected the expected number of characters in the actual <code>String</code>. 206 * @return this assertion object. 207 * @throws AssertionError if the number of characters of the actual <code>String</code> is not equal to the given 208 * one. 209 */ 210 public StringAssert hasSize(int expected) { 211 int actualSize = actualGroupSize(); 212 if (actualSize == expected) return this; 213 failIfCustomMessageIsSet(); 214 throw failure(concat("expected size:", inBrackets(expected)," but was:", inBrackets(actualSize), " for String:", actual())); 215 } 216 217 /** 218 * Returns the number of elements in the actual <code>String</code>. 219 * @return the number of elements in the actual <code>String</code>. 220 */ 221 protected int actualGroupSize() { 222 isNotNull(); 223 return actual.length(); 224 } 225 226 /** 227 * Verifies that the actual <code>String</code> contains the given one. 228 * @param expected the given <code>String</code> expected to be contained in the actual one. 229 * @return this assertion object. 230 * @throws AssertionError if the actual <code>String</code> is <code>null</code>. 231 * @throws AssertionError if the actual <code>String</code> does not contain the given one. 232 */ 233 public StringAssert contains(String expected) { 234 isNotNull(); 235 if (actual.indexOf(expected) != -1) return this; 236 failIfCustomMessageIsSet(); 237 throw failure(concat(actual(), " should contain the String:", inBrackets(expected))); 238 } 239 240 /** 241 * Verifies that the actual <code>String</code> ends with the given one. 242 * @param expected the given <code>String</code> expected to be at the end of the actual one. 243 * @return this assertion object. 244 * @throws AssertionError if the actual <code>String</code> is <code>null</code>. 245 * @throws AssertionError if the actual <code>String</code> does not end with the given one. 246 */ 247 public StringAssert endsWith(String expected) { 248 isNotNull(); 249 if (actual.endsWith(expected)) return this; 250 failIfCustomMessageIsSet(); 251 throw failure(concat(actual(), " should end with:", inBrackets(expected))); 252 } 253 254 /** 255 * Verifies that the actual <code>String</code> starts with the given one. 256 * @param expected the given <code>String</code> expected to be at the beginning of the actual one. 257 * @return this assertion object. 258 * @throws AssertionError if the actual <code>String</code> is <code>null</code>. 259 * @throws AssertionError if the actual <code>String</code> does not start with the given one. 260 */ 261 public StringAssert startsWith(String expected) { 262 isNotNull(); 263 if (actual.startsWith(expected)) return this; 264 failIfCustomMessageIsSet(); 265 throw failure(concat(actual(), " should start with:", inBrackets(expected))); 266 } 267 268 /** 269 * Verifies that the actual <code>String</code> does not contains the given one. 270 * @param s the given <code>String</code> expected not to be contained in the actual one. 271 * @return this assertion object. 272 * @throws AssertionError if the actual <code>String</code> is <code>null</code>. 273 * @throws AssertionError if the actual <code>String</code> does contain the given one. 274 */ 275 public StringAssert excludes(String s) { 276 isNotNull(); 277 if (actual.indexOf(s) == -1) return this; 278 failIfCustomMessageIsSet(); 279 throw failure(concat(actual(), " should not contain the String:", inBrackets(s))); 280 } 281 282 /** 283 * Verifies that the actual <code>String</code> matches the given one. 284 * @param regex the given regular expression expected to be matched by the actual one. 285 * @return this assertion object. 286 * @throws AssertionError if the actual <code>String</code> does not match the given regular expression. 287 */ 288 public StringAssert matches(String regex) { 289 isNotNull(); 290 if (actual.matches(regex)) return this; 291 failIfCustomMessageIsSet(); 292 throw failure(concat(actual(), " should match the regular expression:", inBrackets(regex))); 293 } 294 295 /** 296 * Verifies that the actual <code>String</code> does not match the given one. 297 * @param regex the given regular expression expected not to be matched by the actual one. 298 * @return this assertion object. 299 * @throws AssertionError if the actual <code>String</code> matches the given regular expression. 300 */ 301 public StringAssert doesNotMatch(String regex) { 302 isNotNull(); 303 if (!actual.matches(regex)) return this; 304 failIfCustomMessageIsSet(); 305 throw failure(concat(actual(), " should not match the regular expression:", inBrackets(regex))); 306 } 307 308 private String actual() { 309 return inBrackets(actual); 310 } 311 312 /** {@inheritDoc} */ 313 public StringAssert overridingErrorMessage(String message) { 314 replaceDefaultErrorMessagesWith(message); 315 return this; 316 } 317 }