public void testAddImpliedFeatures_returnsSameSetInstance() throws Exception { Set<Feature<?>> features = Sets.<Feature<?>>newHashSet(ExampleBaseFeature.BASE_FEATURE_1); assertSame(features, FeatureUtil.addImpliedFeatures(features)); }
/** * 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); }
/** * Get 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. */ public static TesterRequirements getTesterRequirements(Class<?> testerClass) throws ConflictingRequirementsException { synchronized (classTesterRequirementsCache) { TesterRequirements requirements = classTesterRequirementsCache.get(testerClass); if (requirements == null) { requirements = buildTesterRequirements(testerClass); classTesterRequirementsCache.put(testerClass, requirements); } return requirements; } }
/** * 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; }
addImpliedFeatures(Helpers.<Feature<?>>copyToSet(presentFeatures)); Set<Feature<?>> allAbsentFeatures = addImpliedFeatures(Helpers.<Feature<?>>copyToSet(absentFeatures)); if (!Collections.disjoint(allPresentFeatures, allAbsentFeatures)) { throw new ConflictingRequirementsException( + "implicitly requires one or more features to be both present " + "and absent.", intersection(allPresentFeatures, allAbsentFeatures), testerAnnotation);
@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())); } }
public void testImpliedFeatures_returnsNewSetInstance() throws Exception { Set<Feature<?>> features = Sets.<Feature<?>>newHashSet(ExampleBaseFeature.BASE_FEATURE_1); assertNotSame(features, FeatureUtil.impliedFeatures(features)); }
private static void checkConflict( String earlierRequirement, Set<Feature<?>> earlierFeatures, String newRequirement, Set<Feature<?>> newFeatures, Object source) throws ConflictingRequirementsException { if (!Collections.disjoint(newFeatures, earlierFeatures)) { throw new ConflictingRequirementsException( String.format( Locale.ROOT, "Annotation requires to be %s features that earlier " + "annotations required to be %s.", newRequirement, earlierRequirement), intersection(newFeatures, earlierFeatures), source); } }
/** * 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; }
requirements = FeatureUtil.getTesterRequirements(method); } catch (ConflictingRequirementsException e) { throw new RuntimeException(e);
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())); }
/** * 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; }
addImpliedFeatures(Helpers.<Feature<?>>copyToSet(presentFeatures)); Set<Feature<?>> allAbsentFeatures = addImpliedFeatures(Helpers.<Feature<?>>copyToSet(absentFeatures)); if (!Collections.disjoint(allPresentFeatures, allAbsentFeatures)) { throw new ConflictingRequirementsException( + "implicitly requires one or more features to be both present " + "and absent.", intersection(allPresentFeatures, allAbsentFeatures), testerAnnotation);
public void testImpliedFeatures_returnsImpliedFeatures() throws Exception { Set<Feature<?>> features; features = Sets.<Feature<?>>newHashSet(ExampleDerivedFeature.DERIVED_FEATURE_1); assertTrue(FeatureUtil.impliedFeatures(features).isEmpty()); features = Sets.<Feature<?>>newHashSet(ExampleDerivedFeature.DERIVED_FEATURE_2); assertThat(FeatureUtil.impliedFeatures(features)).contains(ExampleBaseFeature.BASE_FEATURE_1); features = Sets.<Feature<?>>newHashSet(ExampleDerivedFeature.COMPOUND_DERIVED_FEATURE); assertThat(FeatureUtil.impliedFeatures(features)) .containsExactly( ExampleDerivedFeature.DERIVED_FEATURE_1, ExampleDerivedFeature.DERIVED_FEATURE_2, ExampleBaseFeature.BASE_FEATURE_1, ExampleBaseFeature.BASE_FEATURE_2); }
/** * Construct a new {@link java.util.Set} that is the intersection * of the given sets. */ // Calls generic varargs method. @SuppressWarnings("unchecked") public static <T> Set<T> intersection( Set<? extends T> set1, Set<? extends T> set2) { return intersection(new Set[] {set1, set2}); }
/** * 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; }
requirements = FeatureUtil.getTesterRequirements(method); } catch (ConflictingRequirementsException e) { throw new RuntimeException(e);
/** * 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); } }
/** * Get the full set of requirements for a tester class. * * @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. */ public static TesterRequirements getTesterRequirements(Method testerMethod) throws ConflictingRequirementsException { synchronized (methodTesterRequirementsCache) { TesterRequirements requirements = methodTesterRequirementsCache.get(testerMethod); if (requirements == null) { requirements = buildTesterRequirements(testerMethod); methodTesterRequirementsCache.put(testerMethod, requirements); } return requirements; } }
public void testAddImpliedFeatures_addsImpliedFeatures() throws Exception { Set<Feature<?>> features; features = Sets.<Feature<?>>newHashSet(ExampleDerivedFeature.DERIVED_FEATURE_1); assertThat(FeatureUtil.addImpliedFeatures(features)) .contains(ExampleDerivedFeature.DERIVED_FEATURE_1); features = Sets.<Feature<?>>newHashSet(ExampleDerivedFeature.DERIVED_FEATURE_2); assertThat(FeatureUtil.addImpliedFeatures(features)) .containsExactly( ExampleDerivedFeature.DERIVED_FEATURE_2, ExampleBaseFeature.BASE_FEATURE_1); features = Sets.<Feature<?>>newHashSet(ExampleDerivedFeature.COMPOUND_DERIVED_FEATURE); assertThat(FeatureUtil.addImpliedFeatures(features)) .containsExactly( ExampleDerivedFeature.COMPOUND_DERIVED_FEATURE, ExampleDerivedFeature.DERIVED_FEATURE_1, ExampleDerivedFeature.DERIVED_FEATURE_2, ExampleBaseFeature.BASE_FEATURE_1, ExampleBaseFeature.BASE_FEATURE_2); }