pax_global_header00006660000000000000000000000064124302041160014503gustar00rootroot0000000000000052 comment=1b69203f11e30f73487e6af1c700ad871b08c597 fest-test-2.1.0/000077500000000000000000000000001243020411600134215ustar00rootroot00000000000000fest-test-2.1.0/.gitignore000066400000000000000000000000171243020411600154070ustar00rootroot00000000000000/target /*.iml fest-test-2.1.0/.ignore000066400000000000000000000000241243020411600147010ustar00rootroot00000000000000.classpath .project fest-test-2.1.0/.settings/000077500000000000000000000000001243020411600153375ustar00rootroot00000000000000fest-test-2.1.0/.settings/org.eclipse.jdt.core.prefs000066400000000000000000000110531243020411600223210ustar00rootroot00000000000000eclipse.preferences.version=1 encoding/src/main/java=UTF-8 encoding/src/main/resources=UTF-8 encoding/src/test/java=UTF-8 encoding/src/test/resources=UTF-8 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 org.eclipse.jdt.core.compiler.compliance=1.6 org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning org.eclipse.jdt.core.compiler.problem.autoboxing=ignore org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning org.eclipse.jdt.core.compiler.problem.deadCode=warning org.eclipse.jdt.core.compiler.problem.deprecation=warning org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled org.eclipse.jdt.core.compiler.problem.discouragedReference=warning org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled org.eclipse.jdt.core.compiler.problem.fieldHiding=warning org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=warning org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=warning org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=warning org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=warning org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=warning org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore org.eclipse.jdt.core.compiler.problem.nullReference=warning org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning org.eclipse.jdt.core.compiler.problem.parameterAssignment=warning org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning org.eclipse.jdt.core.compiler.problem.potentialNullReference=warning org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning org.eclipse.jdt.core.compiler.problem.redundantNullCheck=warning org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled org.eclipse.jdt.core.compiler.problem.unusedImport=warning org.eclipse.jdt.core.compiler.problem.unusedLabel=warning org.eclipse.jdt.core.compiler.problem.unusedLocal=warning org.eclipse.jdt.core.compiler.problem.unusedParameter=warning org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning org.eclipse.jdt.core.compiler.source=1.6 fest-test-2.1.0/.settings/org.maven.ide.eclipse.prefs000066400000000000000000000004171243020411600224610ustar00rootroot00000000000000#Wed Aug 12 15:29:32 PDT 2009 activeProfiles= eclipse.preferences.version=1 fullBuildGoals=process-test-resources includeModules=false resolveWorkspaceProjects=true resourceFilterGoals=process-resources resources\:testResources skipCompilerPlugin=true version=1 fest-test-2.1.0/LICENSE.txt000066400000000000000000000261361243020411600152540ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. fest-test-2.1.0/README.md000066400000000000000000000000001243020411600146660ustar00rootroot00000000000000fest-test-2.1.0/pom.xml000077500000000000000000000025511243020411600147440ustar00rootroot00000000000000 4.0.0 fest-test 2.1.0 FEST Testing Utility methods for testing FEST modules 2008 http://fest.easytesting.org org.easytesting fest 1.0.15 Easy Testing Group http://groups.google.com/group/easytesting http://groups.google.com/group/easytesting http://groups.google.com/group/easytesting scm:git:git@github.com:alexruiz/fest-test.git scm:git:git://github.com/alexruiz/fest-test.git https://github.com/alexruiz/fest-test junit junit compile fest-test-2.1.0/src/000077500000000000000000000000001243020411600142105ustar00rootroot00000000000000fest-test-2.1.0/src/main/000077500000000000000000000000001243020411600151345ustar00rootroot00000000000000fest-test-2.1.0/src/main/java/000077500000000000000000000000001243020411600160555ustar00rootroot00000000000000fest-test-2.1.0/src/main/java/org/000077500000000000000000000000001243020411600166445ustar00rootroot00000000000000fest-test-2.1.0/src/main/java/org/fest/000077500000000000000000000000001243020411600176055ustar00rootroot00000000000000fest-test-2.1.0/src/main/java/org/fest/test/000077500000000000000000000000001243020411600205645ustar00rootroot00000000000000fest-test-2.1.0/src/main/java/org/fest/test/Employee.java000066400000000000000000000026631243020411600232150ustar00rootroot00000000000000/* * Created on Feb 22, 2011 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. * * Copyright @2011 the original author or authors. */ package org.fest.test; import static java.lang.String.format; /** * @author Yvonne Wang */ public class Employee { private long id; private Name name; private int age; public Employee() {} public Employee(long id, Name name, int age) { setId(id); setName(name); setAge(age); } public long getId() { return id; } public void setId(long id) { this.id = id; } public Name getName() { return name; } public void setName(Name name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return format("%s[id=%d, name=%s, age=%d]", getClass().getSimpleName(), id, name, age); } } fest-test-2.1.0/src/main/java/org/fest/test/EqualsHashCodeContractAssert.java000066400000000000000000000103401243020411600271360ustar00rootroot00000000000000/* * Created on Apr 12, 2009 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. * * Copyright @2009-2011 the original author or authors. */ package org.fest.test; import static org.junit.Assert.*; /** * Assertion methods that verify that an object's {@code equals} and {@code hashCode} are implemented correctly. * * @author Alex Ruiz */ public final class EqualsHashCodeContractAssert { /** * Verifies that the {@code equals} implementation of the given object returns {@code false} when the object is * compared to {@code null}. * @param obj the object to verify. * @throws AssertionError if the {@code equals} implementation of the given objects returns {@code true} when the * object compared to {@code null}. * @see EqualsHashCodeContractTestCase#should_not_be_equal_to_null() */ public static void assertIsNotEqualToNull(Object obj) { assertFalse(obj.equals(null)); } /** * Verifies that the {@code equals} implementation of the given object is reflexive: the object must be equal to * itself, which it would be at any given instance; unless you intentionally override the equals method to behave * otherwise. * @param obj the object to verify. * @throws AssertionError if the {@code equals} implementation of the given object is reflexive. */ public static void assertEqualsIsReflexive(Object obj) { assertEquals(obj, obj); } /** * Verifies that the {@code equals} implementation of the given objects is symmetric: if object of one class is equal * to another class object, the other class object must be equal to this class object. In other words, one object can * not unilaterally decide whether it is equal to another object; two objects, and consequently the classes to which * they belong, must bilaterally decide if they are equal or not. They BOTH must agree. * @param obj1 the object to verify. * @param obj2 the object to compare to. * @throws AssertionError if the {@code equals} implementation of the given object is not symmetric. */ public static void assertEqualsIsSymmetric(Object obj1, Object obj2) { assertEquals(obj1, obj2); assertEquals(obj2, obj1); } /** * Verifies that the {@code equals} implementation of the given objects is transitive: if the first object is equal to * the second object and the second object is equal to the third object; then the first object is equal to the third * object. In other words, if two objects agree that they are equal, and follow the symmetry principle, one of them * can not decide to have a similar contract with another object of different class. All three must agree and follow * symmetry principle for various permutations of these three classes. * @param obj1 the object to verify. * @param obj2 an object to compare to. * @param obj3 an object to compare to. * @throws AssertionError if the {@code equals} implementation of the given objects is not transitive. */ public static void assertEqualsIsTransitive(Object obj1, Object obj2, Object obj3) { assertEquals(obj1, obj2); assertEquals(obj2, obj3); assertEquals(obj1, obj3); } /** * Verifies that the {@code equals}/{@code hashCode} contract of the given objects is implemented correctly: if two * objects are equal, then they must have the same hash code, however the opposite is NOT true. * @param obj1 the object to verify. * @param obj2 the object to compare to. * @throws AssertionError if the {@code equals}/{@code hashCode} contract of the given objects is not implemented * correctly. */ public static void assertMaintainsEqualsAndHashCodeContract(Object obj1, Object obj2) { assertEquals(obj1, obj2); assertEquals(obj1.hashCode(), obj2.hashCode()); } private EqualsHashCodeContractAssert() {} } fest-test-2.1.0/src/main/java/org/fest/test/EqualsHashCodeContractTestCase.java000066400000000000000000000050251243020411600274140ustar00rootroot00000000000000/* * Created on Apr 12, 2009 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. * * Copyright @2009-2011 the original author or authors. */ package org.fest.test; /** * Test case that provides the contract for verification that an object's {@code equals} and {@code hashCode} are * implemented correctly. * * @author Alex Ruiz */ public interface EqualsHashCodeContractTestCase { void should_not_be_equal_to_Object_of_different_type(); /** * If two objects are equal, they must remain equal as long as they are not modified. */ void equals_should_be_consistent(); /** * The object must be equal to itself, which it would be at any given instance; unless you intentionally override the * equals method to behave otherwise. */ void equals_should_be_reflexive(); /** * If object of one class is equal to another class object, the other class object must be equal to this class object. * In other words, one object can not unilaterally decide whether it is equal to another object; two objects, and * consequently the classes to which they belong, must bilaterally decide if they are equal or not. They BOTH must * agree. */ void equals_should_be_symmetric(); /** * If the first object is equal to the second object and the second object is equal to the third object; then the * first object is equal to the third object. In other words, if two objects agree that they are equal, and follow the * symmetry principle, one of them can not decide to have a similar contract with another object of different class. * All three must agree and follow symmetry principle for various permutations of these three classes. */ void equals_should_be_transitive(); /** * If two objects are equal, then they must have the same hash code, however the opposite is NOT true. */ void should_maintain_equals_and_hashCode_contract(); /** * Verifies that the implementation of the method {@code equals} returns {@code false} if a {@code null} is passed as * argument. */ void should_not_be_equal_to_null(); } fest-test-2.1.0/src/main/java/org/fest/test/Jedi.java000066400000000000000000000023021243020411600222770ustar00rootroot00000000000000/* * Created on Mar 19, 2012 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. * * Copyright @2012 the original author or authors. */ package org.fest.test; /** * Object for test. * * @author Nicolas François * @author Joel Costigliola */ public class Jedi extends Person { private String lightSaberColor; @SuppressWarnings("unused") private Object strangeNotReadablePrivateField; public Jedi(String name, String lightSaberColor) { super(name); this.lightSaberColor = lightSaberColor; } public String getLightSaberColor() { return lightSaberColor; } @Override public String toString() { return getName() + " the Jedi"; } } fest-test-2.1.0/src/main/java/org/fest/test/Name.java000066400000000000000000000025201243020411600223060ustar00rootroot00000000000000/* * Created on Feb 22, 2011 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. * * Copyright @2011 the original author or authors. */ package org.fest.test; /** * @author Yvonne Wang */ public class Name { private String first; private String last; public Name() {} public Name(String first) { setFirst(first); } public Name(String first, String last) { setFirst(first); setLast(last); } public String getFirst() { return first; } public void setFirst(String first) { this.first = first; } public String getLast() { return last; } public void setLast(String last) { this.last = last; } @Override public String toString() { return String.format("%s[first='%s', last='%s']", getClass().getSimpleName(), first, last); } } fest-test-2.1.0/src/main/java/org/fest/test/ParameterSource.java000066400000000000000000000021511243020411600245270ustar00rootroot00000000000000/* * Created on Oct 7, 2010 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. * * Copyright @2010-2011 the original author or authors. */ package org.fest.test; import static java.util.Collections.unmodifiableList; import java.util.*; /** * Data provider for parameterized tests. * * @author Alex Ruiz */ public class ParameterSource { public static List parametersFrom(List values) { List parameters = new ArrayList(); for (Object value : values) parameters.add(new Object[] { value }); return unmodifiableList(parameters); } private ParameterSource() {} } fest-test-2.1.0/src/main/java/org/fest/test/Person.java000066400000000000000000000031311243020411600226730ustar00rootroot00000000000000/* * Created on Sep 17, 2010 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. * * Copyright @2010-2011 the original author or authors. */ package org.fest.test; /** * A person. * * @author Alex Ruiz */ public class Person implements Comparable { private final String name; public Person(String name) { this.name = name; } public String getName() { return name; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public int compareTo(Person other) { return name.compareTo(other.name); } @Override public String toString() { return String.format("Person[name='%s']", name); } } fest-test-2.1.0/src/main/java/org/fest/test/PersonCaseInsensitiveNameComparator.java000066400000000000000000000020011243020411600305340ustar00rootroot00000000000000/* * Created on Sep 17, 2010 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. * * Copyright @2010-2011 the original author or authors. */ package org.fest.test; import java.util.Comparator; /** * A {@link Person} comparator comparing name case insensitively. * * @author Joel Costigliola */ public class PersonCaseInsensitiveNameComparator implements Comparator { @Override public int compare(Person p1, Person p2) { return p1.getName().toLowerCase().compareTo(p2.getName().toLowerCase()); } } fest-test-2.1.0/src/main/java/org/fest/test/Player.java000066400000000000000000000036561243020411600226750ustar00rootroot00000000000000/* * Created on Feb 22, 2011 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. * * Copyright @2011 the original author or authors. */ package org.fest.test; import static java.lang.String.format; /** * @author Joel Costigliola */ public class Player { private Name name; private int pointsPerGame; private int assistsPerGame; private int reboundsPerGame; private String team; public Player() {} public Player(Name name, String team) { setName(name); setTeam(team); } public Name getName() { return name; } public void setName(Name name) { this.name = name; } public int getPointsPerGame() { return pointsPerGame; } public void setPointsPerGame(int pointsPerGame) { this.pointsPerGame = pointsPerGame; } public int getAssistsPerGame() { return assistsPerGame; } public void setAssistsPerGame(int assistsPerGame) { this.assistsPerGame = assistsPerGame; } public int getReboundsPerGame() { return reboundsPerGame; } public void setReboundsPerGame(int reboundsPerGame) { this.reboundsPerGame = reboundsPerGame; } public String getTeam() { return team; } public void setTeam(String team) { this.team = team; } @Override public String toString() { return format("%s[%s %s, team=%s]", getClass().getSimpleName(), name.getFirst(), name.getLast(), team); } } fest-test-2.1.0/src/main/java/org/fest/test/TestFailures.java000066400000000000000000000016451243020411600240470ustar00rootroot00000000000000/* * Created on Jan 22, 2011 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. * * Copyright @2011 the original author or authors. */ package org.fest.test; import org.junit.Assert; /** * @author Yvonne Wang */ public final class TestFailures { public static void failBecauseExpectedAssertionErrorWasNotThrown() { Assert.fail("Assertion error expected"); } private TestFailures() {} }