001 /* 002 * Created on Jul 26, 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 019 import org.fest.assertions.core.ArraySortedAssert; 020 import org.fest.assertions.core.Condition; 021 import org.fest.assertions.core.IndexedObjectEnumerableAssert; 022 import org.fest.assertions.core.ObjectEnumerableAssert; 023 import org.fest.assertions.data.Index; 024 import org.fest.assertions.internal.ObjectArrays; 025 import org.fest.util.ComparatorBasedComparisonStrategy; 026 import org.fest.util.VisibleForTesting; 027 028 /** 029 * Assertion methods for arrays of objects. 030 * <p> 031 * To create an instance of this class, invoke <code>{@link Assertions#assertThat(Object[])}</code>. 032 * </p> 033 * 034 * @author Yvonne Wang 035 * @author Alex Ruiz 036 * @author Joel Costigliola 037 * @author Nicolas François 038 */ 039 public class ObjectArrayAssert extends AbstractAssert<ObjectArrayAssert, Object[]> implements 040 ObjectEnumerableAssert<ObjectArrayAssert>, IndexedObjectEnumerableAssert, ArraySortedAssert<ObjectArrayAssert, Object> { 041 042 @VisibleForTesting 043 ObjectArrays arrays = ObjectArrays.instance(); 044 045 protected ObjectArrayAssert(Object[] actual) { 046 super(actual, ObjectArrayAssert.class); 047 } 048 049 /** {@inheritDoc} */ 050 public void isNullOrEmpty() { 051 arrays.assertNullOrEmpty(info, actual); 052 } 053 054 /** {@inheritDoc} */ 055 public void isEmpty() { 056 arrays.assertEmpty(info, actual); 057 } 058 059 /** {@inheritDoc} */ 060 public ObjectArrayAssert isNotEmpty() { 061 arrays.assertNotEmpty(info, actual); 062 return this; 063 } 064 065 /** {@inheritDoc} */ 066 public ObjectArrayAssert hasSize(int expected) { 067 arrays.assertHasSize(info, actual, expected); 068 return this; 069 } 070 071 /** {@inheritDoc} */ 072 public ObjectArrayAssert contains(Object... values) { 073 arrays.assertContains(info, actual, values); 074 return this; 075 } 076 077 /** {@inheritDoc} */ 078 public ObjectArrayAssert containsOnly(Object... values) { 079 arrays.assertContainsOnly(info, actual, values); 080 return this; 081 } 082 083 /** {@inheritDoc} */ 084 public ObjectArrayAssert containsSequence(Object... sequence) { 085 arrays.assertContainsSequence(info, actual, sequence); 086 return this; 087 } 088 089 /** {@inheritDoc} */ 090 public ObjectArrayAssert contains(Object value, Index index) { 091 arrays.assertContains(info, actual, value, index); 092 return this; 093 } 094 095 /** {@inheritDoc} */ 096 public ObjectArrayAssert doesNotContain(Object value, Index index) { 097 arrays.assertDoesNotContain(info, actual, value, index); 098 return this; 099 } 100 101 /** {@inheritDoc} */ 102 public ObjectArrayAssert doesNotContain(Object... values) { 103 arrays.assertDoesNotContain(info, actual, values); 104 return this; 105 } 106 107 /** {@inheritDoc} */ 108 public ObjectArrayAssert doesNotHaveDuplicates() { 109 arrays.assertDoesNotHaveDuplicates(info, actual); 110 return this; 111 } 112 113 /** {@inheritDoc} */ 114 public ObjectArrayAssert startsWith(Object... sequence) { 115 arrays.assertStartsWith(info, actual, sequence); 116 return this; 117 } 118 119 /** {@inheritDoc} */ 120 public ObjectArrayAssert endsWith(Object... sequence) { 121 arrays.assertEndsWith(info, actual, sequence); 122 return this; 123 } 124 125 /** {@inheritDoc} */ 126 public ObjectArrayAssert containsNull() { 127 arrays.assertContainsNull(info, actual); 128 return this; 129 } 130 131 /** {@inheritDoc} */ 132 public ObjectArrayAssert doesNotContainNull() { 133 arrays.assertDoesNotContainNull(info, actual); 134 return this; 135 } 136 137 /** {@inheritDoc} */ 138 public <E> ObjectArrayAssert are(Condition<E> condition) { 139 arrays.assertAre(info, actual, condition); 140 return myself; 141 } 142 143 /** {@inheritDoc} */ 144 public <E> ObjectArrayAssert areNot(Condition<E> condition) { 145 arrays.assertAreNot(info, actual, condition); 146 return myself; 147 } 148 149 /** {@inheritDoc} */ 150 public <E> ObjectArrayAssert have(Condition<E> condition) { 151 arrays.assertHave(info, actual, condition); 152 return myself; 153 } 154 155 /** {@inheritDoc} */ 156 public <E> ObjectArrayAssert doNotHave(Condition<E> condition) { 157 arrays.assertDoNotHave(info, actual, condition); 158 return myself; 159 } 160 161 /** {@inheritDoc} */ 162 public <E> ObjectArrayAssert areAtLeast(int times, Condition<E> condition) { 163 arrays.assertAreAtLeast(info, actual, times, condition); 164 return myself; 165 } 166 167 /** {@inheritDoc} */ 168 public <E> ObjectArrayAssert areNotAtLeast(int times, Condition<E> condition) { 169 arrays.assertAreNotAtLeast(info, actual, times, condition); 170 return myself; 171 } 172 173 /** {@inheritDoc} */ 174 public <E> ObjectArrayAssert areAtMost(int times, Condition<E> condition) { 175 arrays.assertAreAtMost(info, actual, times, condition); 176 return myself; 177 } 178 179 /** {@inheritDoc} */ 180 public <E> ObjectArrayAssert areNotAtMost(int times, Condition<E> condition) { 181 arrays.assertAreNotAtMost(info, actual, times, condition); 182 return myself; 183 } 184 185 /** {@inheritDoc} */ 186 public <E> ObjectArrayAssert areExactly(int times, Condition<E> condition) { 187 arrays.assertAreExactly(info, actual, times, condition); 188 return myself; 189 } 190 191 /** {@inheritDoc} */ 192 public <E> ObjectArrayAssert areNotExactly(int times, Condition<E> condition) { 193 arrays.assertAreNotExactly(info, actual, times, condition); 194 return myself; 195 } 196 197 /** {@inheritDoc} */ 198 public <E> ObjectArrayAssert haveAtLeast(int times, Condition<E> condition) { 199 arrays.assertHaveAtLeast(info, actual, times, condition); 200 return myself; 201 } 202 203 /** {@inheritDoc} */ 204 public <E> ObjectArrayAssert doNotHaveAtLeast(int times, Condition<E> condition) { 205 arrays.assertDoNotHaveAtLeast(info, actual, times, condition); 206 return myself; 207 } 208 209 /** {@inheritDoc} */ 210 public <E> ObjectArrayAssert haveAtMost(int times, Condition<E> condition) { 211 arrays.assertHaveAtMost(info, actual, times, condition); 212 return myself; 213 } 214 215 /** {@inheritDoc} */ 216 public <E> ObjectArrayAssert doNotHaveAtMost(int times, Condition<E> condition) { 217 arrays.assertDoNotHaveAtMost(info, actual, times, condition); 218 return myself; 219 } 220 221 /** {@inheritDoc} */ 222 public <E> ObjectArrayAssert haveExactly(int times, Condition<E> condition) { 223 arrays.assertHaveExactly(info, actual, times, condition); 224 return myself; 225 } 226 227 /** {@inheritDoc} */ 228 public <E> ObjectArrayAssert doNotHaveExactly(int times, Condition<E> condition) { 229 arrays.assertDoNotHaveExactly(info, actual, times, condition); 230 return myself; 231 } 232 233 /** {@inheritDoc} */ 234 public ObjectArrayAssert isSorted() { 235 arrays.assertIsSorted(info, actual); 236 return this; 237 } 238 239 /** {@inheritDoc} */ 240 public ObjectArrayAssert isSortedAccordingTo(Comparator<? extends Object> comparator) { 241 arrays.assertIsSortedAccordingToComparator(info, actual, comparator); 242 return this; 243 } 244 245 @Override 246 public ObjectArrayAssert usingComparator(Comparator<?> customComparator) { 247 super.usingComparator(customComparator); 248 this.arrays = new ObjectArrays(new ComparatorBasedComparisonStrategy(customComparator)); 249 return myself; 250 } 251 252 @Override 253 public ObjectArrayAssert usingDefaultComparator() { 254 super.usingDefaultComparator(); 255 this.arrays = ObjectArrays.instance(); 256 return myself; 257 } 258 259 260 261 }