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 * @author Mikhail Mazursky 037 */ 038 public class StringAssert extends AbstractAssert<StringAssert, String> implements EnumerableAssert<StringAssert, String> { 039 040 @VisibleForTesting Strings strings = Strings.instance(); 041 042 protected StringAssert(String actual) { 043 super(actual, StringAssert.class); 044 } 045 046 /** {@inheritDoc} */ 047 public void isNullOrEmpty() { 048 strings.assertNullOrEmpty(info, actual); 049 } 050 051 /** {@inheritDoc} */ 052 public void isEmpty() { 053 strings.assertEmpty(info, actual); 054 } 055 056 /** {@inheritDoc} */ 057 public StringAssert isNotEmpty() { 058 strings.assertNotEmpty(info, actual); 059 return this; 060 } 061 062 /** {@inheritDoc} */ 063 public StringAssert hasSize(int expected) { 064 strings.assertHasSize(info, actual, expected); 065 return this; 066 } 067 068 /** 069 * Verifies that the actual {@code String} is equal to the given one, ignoring case considerations. 070 * @param expected the given {@code String} to compare the actual {@code String} to. 071 * @return {@code this} assertion object. 072 * @throws AssertionError if the actual {@code String} is not equal to the given one. 073 */ 074 public StringAssert isEqualToIgnoringCase(String expected) { 075 strings.assertEqualsIgnoringCase(info, actual, expected); 076 return this; 077 } 078 079 /** 080 * Verifies that the actual {@code String} contains the given sequence. 081 * @param sequence the sequence to search for. 082 * @return {@code this} assertion object. 083 * @throws NullPointerException if the given sequence is {@code null}. 084 * @throws AssertionError if the actual {@code String} is {@code null}. 085 * @throws AssertionError if the actual {@code String} does not contain the given one. 086 */ 087 public StringAssert contains(String sequence) { 088 strings.assertContains(info, actual, sequence); 089 return this; 090 } 091 092 /** 093 * Verifies that the actual {@code String} contains the given sequence, ignoring case considerations. 094 * @param sequence the sequence to search for. 095 * @return {@code this} assertion object. 096 * @throws NullPointerException if the given sequence is {@code null}. 097 * @throws AssertionError if the actual {@code String} is {@code null}. 098 * @throws AssertionError if the actual {@code String} does not contain the given one. 099 */ 100 public StringAssert containsIgnoringCase(String sequence) { 101 strings.assertContainsIgnoringCase(info, actual, sequence); 102 return this; 103 } 104 105 /** 106 * Verifies that the actual {@code String} does not contain the given sequence. 107 * @param sequence the sequence to search for. 108 * @return {@code this} assertion object. 109 * @throws NullPointerException if the given sequence is {@code null}. 110 * @throws AssertionError if the actual {@code String} is {@code null}. 111 * @throws AssertionError if the actual {@code String} contains the given one. 112 */ 113 public StringAssert doesNotContain(String sequence) { 114 strings.assertDoesNotContain(info, actual, sequence); 115 return this; 116 } 117 118 /** 119 * Verifies that the actual {@code String} starts with the given prefix. 120 * @param prefix the given prefix. 121 * @return {@code this} assertion object. 122 * @throws NullPointerException if the given prefix is {@code null}. 123 * @throws AssertionError if the actual {@code String} is {@code null}. 124 * @throws AssertionError if the actual {@code String} does not start with the given prefix. 125 */ 126 public StringAssert startsWith(String prefix) { 127 strings.assertStartsWith(info, actual, prefix); 128 return this; 129 } 130 131 /** 132 * Verifies that the actual {@code String} ends with the given suffix. 133 * @param suffix the given suffix. 134 * @return {@code this} assertion object. 135 * @throws NullPointerException if the given suffix is {@code null}. 136 * @throws AssertionError if the actual {@code String} is {@code null}. 137 * @throws AssertionError if the actual {@code String} does not end with the given suffix. 138 */ 139 public StringAssert endsWith(String suffix) { 140 strings.assertEndsWith(info, actual, suffix); 141 return this; 142 } 143 144 /** 145 * Verifies that the actual {@code String} matches the given regular expression. 146 * @param regex the regular expression to which the actual {@code String} is to be matched. 147 * @return {@code this} assertion object. 148 * @throws NullPointerException if the given pattern is {@code null}. 149 * @throws PatternSyntaxException if the regular expression's syntax is invalid. 150 * @throws AssertionError if the actual {@code String} is {@code null}. 151 * @throws AssertionError if the actual {@code String} does not match the given regular expression. 152 */ 153 public StringAssert matches(String regex) { 154 strings.assertMatches(info, actual, regex); 155 return this; 156 } 157 158 /** 159 * Verifies that the actual {@code String} does not match the given regular expression. 160 * @param regex the regular expression to which the actual {@code String} is to be matched. 161 * @return {@code this} assertion object. 162 * @throws NullPointerException if the given pattern is {@code null}. 163 * @throws PatternSyntaxException if the regular expression's syntax is invalid. 164 * @throws AssertionError if the actual {@code String} is {@code null}. 165 * @throws AssertionError if the actual {@code String} matches the given regular expression. 166 */ 167 public StringAssert doesNotMatch(String regex) { 168 strings.assertDoesNotMatch(info, actual, regex); 169 return this; 170 } 171 172 /** 173 * Verifies that the actual {@code String} matches the given regular expression. 174 * @param pattern the regular expression to which the actual {@code String} is to be matched. 175 * @return {@code this} assertion object. 176 * @throws NullPointerException if the given pattern is {@code null}. 177 * @throws AssertionError if the actual {@code String} is {@code null}. 178 * @throws AssertionError if the actual {@code String} does not match the given regular expression. 179 */ 180 public StringAssert matches(Pattern pattern) { 181 strings.assertMatches(info, actual, pattern); 182 return this; 183 } 184 185 /** 186 * Verifies that the actual {@code String} does not match the given regular expression. 187 * @param pattern the regular expression to which the actual {@code String} is to be matched. 188 * @return {@code this} assertion object. 189 * @throws NullPointerException if the given pattern is {@code null}. 190 * @throws AssertionError if the actual {@code String} does not match the given regular expression. 191 */ 192 public StringAssert doesNotMatch(Pattern pattern) { 193 strings.assertDoesNotMatch(info, actual, pattern); 194 return this; 195 } 196 197 /** {@inheritDoc} */ 198 public StringAssert usingElementComparator(Comparator<? super String> customComparator) { 199 // TODO maybe use Comparator<? super Character> 200 throw new UnsupportedOperationException("custom element Comparator is not supported for String comparison"); 201 } 202 203 /** {@inheritDoc} */ 204 public StringAssert usingDefaultElementComparator() { 205 throw new UnsupportedOperationException("custom element Comparator is not supported for String comparison"); 206 } 207 208 @Override 209 public StringAssert usingComparator(Comparator<? super String> customComparator) { 210 super.usingComparator(customComparator); 211 this.strings = new Strings(new ComparatorBasedComparisonStrategy(customComparator)); 212 return myself; 213 } 214 215 @Override 216 public StringAssert usingDefaultComparator() { 217 super.usingDefaultComparator(); 218 this.strings = Strings.instance(); 219 return myself; 220 } 221 }