/** * Construct the full set of requirements for a tester method. * * @param testerMethod a test method of a tester class * @return all the constraints implicitly or explicitly required by the method, its declaring * class, or any of its superclasses. * @throws ConflictingRequirementsException if the requirements are mutually inconsistent. */ static TesterRequirements buildTesterRequirements(Method testerMethod) throws ConflictingRequirementsException { TesterRequirements clonedClassRequirements = new TesterRequirements(getTesterRequirements(testerMethod.getDeclaringClass())); TesterRequirements declaredRequirements = buildDeclaredTesterRequirements(testerMethod); return incorporateRequirements(clonedClassRequirements, declaredRequirements, testerMethod); }
public TesterRequirements(TesterRequirements tr) { this(tr.getPresentFeatures(), tr.getAbsentFeatures()); }
/** * Construct the full set of requirements for a tester class. * * @param testerClass a tester class * @return all the constraints implicitly or explicitly required by the class or any of its * superclasses. * @throws ConflictingRequirementsException if the requirements are mutually inconsistent. */ static TesterRequirements buildTesterRequirements(Class<?> testerClass) throws ConflictingRequirementsException { final TesterRequirements declaredRequirements = buildDeclaredTesterRequirements(testerClass); Class<?> baseClass = testerClass.getSuperclass(); if (baseClass == null) { return declaredRequirements; } else { final TesterRequirements clonedBaseRequirements = new TesterRequirements(getTesterRequirements(baseClass)); return incorporateRequirements(clonedBaseRequirements, declaredRequirements, testerClass); } }
/** * Incorporate additional requirements into an existing requirements object. * * @param requirements the existing requirements object * @param moreRequirements more requirements to incorporate * @param source the source of the additional requirements (used only for error reporting) * @return the existing requirements object, modified to include the additional requirements * @throws ConflictingRequirementsException if the additional requirements are inconsistent with * the existing requirements */ private static TesterRequirements incorporateRequirements( TesterRequirements requirements, TesterRequirements moreRequirements, Object source) throws ConflictingRequirementsException { Set<Feature<?>> presentFeatures = requirements.getPresentFeatures(); Set<Feature<?>> absentFeatures = requirements.getAbsentFeatures(); Set<Feature<?>> morePresentFeatures = moreRequirements.getPresentFeatures(); Set<Feature<?>> moreAbsentFeatures = moreRequirements.getAbsentFeatures(); checkConflict("absent", absentFeatures, "present", morePresentFeatures, source); checkConflict("present", presentFeatures, "absent", moreAbsentFeatures, source); presentFeatures.addAll(morePresentFeatures); absentFeatures.addAll(moreAbsentFeatures); return requirements; }
testerAnnotation); return new TesterRequirements(allPresentFeatures, allAbsentFeatures);
throw new RuntimeException(e); if (!features.containsAll(requirements.getPresentFeatures())) { if (logger.isLoggable(FINER)) { Set<Feature<?>> missingFeatures = Helpers.copyToSet(requirements.getPresentFeatures()); missingFeatures.removeAll(features); logger.finer( if (intersect(features, requirements.getAbsentFeatures())) { if (logger.isLoggable(FINER)) { Set<Feature<?>> unwantedFeatures = Helpers.copyToSet(requirements.getAbsentFeatures()); unwantedFeatures.retainAll(features); logger.finer(
/** * Construct the set of requirements specified by annotations directly on a tester class or * method. * * @param classOrMethod a tester class or a test method thereof * @return all the constraints implicitly or explicitly required by annotations on the class or * method. * @throws ConflictingRequirementsException if the requirements are mutually inconsistent. */ public static TesterRequirements buildDeclaredTesterRequirements(AnnotatedElement classOrMethod) throws ConflictingRequirementsException { TesterRequirements requirements = new TesterRequirements(); Iterable<Annotation> testerAnnotations = getTesterAnnotations(classOrMethod); for (Annotation testerAnnotation : testerAnnotations) { TesterRequirements moreRequirements = buildTesterRequirements(testerAnnotation); incorporateRequirements(requirements, moreRequirements, testerAnnotation); } return requirements; }
public TesterRequirements(TesterRequirements tr) { this(tr.getPresentFeatures(), tr.getAbsentFeatures()); }
@AndroidIncompatible // Android runs ExampleDerivedInterfaceTester directly if it exists public void testBuildTesterRequirements_class() throws Exception { assertEquals( FeatureUtil.buildTesterRequirements(ExampleBaseInterfaceTester.class), new TesterRequirements( Sets.<Feature<?>>newHashSet(ExampleBaseFeature.BASE_FEATURE_1), Collections.<Feature<?>>emptySet())); assertEquals( FeatureUtil.buildTesterRequirements(ExampleDerivedInterfaceTester.class), new TesterRequirements( Sets.<Feature<?>>newHashSet( ExampleBaseFeature.BASE_FEATURE_1, ExampleDerivedFeature.DERIVED_FEATURE_2), Collections.<Feature<?>>emptySet())); }
public TesterRequirements(TesterRequirements tr) { this(tr.getPresentFeatures(), tr.getAbsentFeatures()); }
@AndroidIncompatible // Android runs ExampleDerivedInterfaceTester directly if it exists public void testBuildTesterRequirements_method() throws Exception { assertEquals( FeatureUtil.buildTesterRequirements( ExampleDerivedInterfaceTester.class.getMethod( "testRequiringTwoExplicitDerivedFeatures")), new TesterRequirements( Sets.<Feature<?>>newHashSet( ExampleBaseFeature.BASE_FEATURE_1, ExampleDerivedFeature.DERIVED_FEATURE_1, ExampleDerivedFeature.DERIVED_FEATURE_2), Collections.<Feature<?>>emptySet())); assertEquals( FeatureUtil.buildTesterRequirements( ExampleDerivedInterfaceTester.class.getMethod("testRequiringAllThreeDerivedFeatures")), new TesterRequirements( Sets.<Feature<?>>newHashSet( ExampleBaseFeature.BASE_FEATURE_1, ExampleDerivedFeature.DERIVED_FEATURE_1, ExampleDerivedFeature.DERIVED_FEATURE_2, ExampleDerivedFeature.DERIVED_FEATURE_3), Collections.<Feature<?>>emptySet())); }
/** * Incorporate additional requirements into an existing requirements object. * * @param requirements the existing requirements object * @param moreRequirements more requirements to incorporate * @param source the source of the additional requirements (used only for error reporting) * @return the existing requirements object, modified to include the additional requirements * @throws ConflictingRequirementsException if the additional requirements are inconsistent with * the existing requirements */ private static TesterRequirements incorporateRequirements( TesterRequirements requirements, TesterRequirements moreRequirements, Object source) throws ConflictingRequirementsException { Set<Feature<?>> presentFeatures = requirements.getPresentFeatures(); Set<Feature<?>> absentFeatures = requirements.getAbsentFeatures(); Set<Feature<?>> morePresentFeatures = moreRequirements.getPresentFeatures(); Set<Feature<?>> moreAbsentFeatures = moreRequirements.getAbsentFeatures(); checkConflict("absent", absentFeatures, "present", morePresentFeatures, source); checkConflict("present", presentFeatures, "absent", moreAbsentFeatures, source); presentFeatures.addAll(morePresentFeatures); absentFeatures.addAll(moreAbsentFeatures); return requirements; }
@AndroidIncompatible // Android runs ExampleDerivedInterfaceTester directly if it exists public void testBuildDeclaredTesterRequirements() throws Exception { assertEquals( FeatureUtil.buildDeclaredTesterRequirements( ExampleDerivedInterfaceTester.class.getMethod( "testRequiringTwoExplicitDerivedFeatures")), new TesterRequirements( FeatureUtil.addImpliedFeatures( Sets.<Feature<?>>newHashSet( ExampleDerivedFeature.DERIVED_FEATURE_1, ExampleDerivedFeature.DERIVED_FEATURE_2)), Collections.<Feature<?>>emptySet())); } }
/** * Incorporate additional requirements into an existing requirements object. * @param requirements the existing requirements object * @param moreRequirements more requirements to incorporate * @param source the source of the additional requirements * (used only for error reporting) * @return the existing requirements object, modified to include the * additional requirements * @throws ConflictingRequirementsException if the additional requirements * are inconsistent with the existing requirements */ private static TesterRequirements incorporateRequirements( TesterRequirements requirements, TesterRequirements moreRequirements, Object source) throws ConflictingRequirementsException { Set<Feature<?>> presentFeatures = requirements.getPresentFeatures(); Set<Feature<?>> absentFeatures = requirements.getAbsentFeatures(); Set<Feature<?>> morePresentFeatures = moreRequirements.getPresentFeatures(); Set<Feature<?>> moreAbsentFeatures = moreRequirements.getAbsentFeatures(); checkConflict( "absent", absentFeatures, "present", morePresentFeatures, source); checkConflict( "present", presentFeatures, "absent", moreAbsentFeatures, source); presentFeatures.addAll(morePresentFeatures); absentFeatures.addAll(moreAbsentFeatures); return requirements; }
/** * Construct the full set of requirements for a tester method. * * @param testerMethod a test method of a tester class * @return all the constraints implicitly or explicitly required by the method, its declaring * class, or any of its superclasses. * @throws ConflictingRequirementsException if the requirements are mutually inconsistent. */ static TesterRequirements buildTesterRequirements(Method testerMethod) throws ConflictingRequirementsException { TesterRequirements clonedClassRequirements = new TesterRequirements(getTesterRequirements(testerMethod.getDeclaringClass())); TesterRequirements declaredRequirements = buildDeclaredTesterRequirements(testerMethod); return incorporateRequirements(clonedClassRequirements, declaredRequirements, testerMethod); }
throw new RuntimeException(e); if (!features.containsAll(requirements.getPresentFeatures())) { if (logger.isLoggable(FINER)) { Set<Feature<?>> missingFeatures = Helpers.copyToSet(requirements.getPresentFeatures()); missingFeatures.removeAll(features); logger.finer( if (intersect(features, requirements.getAbsentFeatures())) { if (logger.isLoggable(FINER)) { Set<Feature<?>> unwantedFeatures = Helpers.copyToSet(requirements.getAbsentFeatures()); unwantedFeatures.retainAll(features); logger.finer(
/** * Construct the full set of requirements for a tester method. * @param testerMethod a test method of a tester class * @return all the constraints implicitly or explicitly required by the * method, its declaring class, or any of its superclasses. * @throws ConflictingRequirementsException if the requirements are mutually * inconsistent. */ static TesterRequirements buildTesterRequirements(Method testerMethod) throws ConflictingRequirementsException { TesterRequirements clonedClassRequirements = new TesterRequirements( getTesterRequirements(testerMethod.getDeclaringClass())); TesterRequirements declaredRequirements = buildDeclaredTesterRequirements(testerMethod); return incorporateRequirements( clonedClassRequirements, declaredRequirements, testerMethod); }
throw new RuntimeException(e); if (!features.containsAll(requirements.getPresentFeatures())) { if (logger.isLoggable(FINER)) { Set<Feature<?>> missingFeatures = Helpers.copyToSet(requirements.getPresentFeatures()); missingFeatures.removeAll(features); logger.finer(Platform.format( if (intersect(features, requirements.getAbsentFeatures())) { if (logger.isLoggable(FINER)) { Set<Feature<?>> unwantedFeatures = Helpers.copyToSet(requirements.getAbsentFeatures()); unwantedFeatures.retainAll(features); logger.finer(Platform.format(
/** * Construct the full set of requirements for a tester class. * * @param testerClass a tester class * @return all the constraints implicitly or explicitly required by the class or any of its * superclasses. * @throws ConflictingRequirementsException if the requirements are mutually inconsistent. */ static TesterRequirements buildTesterRequirements(Class<?> testerClass) throws ConflictingRequirementsException { final TesterRequirements declaredRequirements = buildDeclaredTesterRequirements(testerClass); Class<?> baseClass = testerClass.getSuperclass(); if (baseClass == null) { return declaredRequirements; } else { final TesterRequirements clonedBaseRequirements = new TesterRequirements(getTesterRequirements(baseClass)); return incorporateRequirements(clonedBaseRequirements, declaredRequirements, testerClass); } }
/** * Construct the full set of requirements for a tester class. * @param testerClass a tester class * @return all the constraints implicitly or explicitly required by the class * or any of its superclasses. * @throws ConflictingRequirementsException if the requirements are mutually * inconsistent. */ static TesterRequirements buildTesterRequirements(Class<?> testerClass) throws ConflictingRequirementsException { final TesterRequirements declaredRequirements = buildDeclaredTesterRequirements(testerClass); Class<?> baseClass = testerClass.getSuperclass(); if (baseClass == null) { return declaredRequirements; } else { final TesterRequirements clonedBaseRequirements = new TesterRequirements(getTesterRequirements(baseClass)); return incorporateRequirements( clonedBaseRequirements, declaredRequirements, testerClass); } }