@Test
 public void buildShouldRunOnClassExtendingAbstractClass() {
   List<Class<?>> testClasses =
       Arrays.asList(
           TestClassOne.class,
           TestClassTwo.class,
           TestClassOnInterfaceOne.class,
           TestClassOnInterfaceTwo.class);
   AnnotationBasedMetadataBuilder builder = new AnnotationBasedMetadataBuilder();
   List<Class<?>> classesUnderTest = new LinkedList<Class<?>>();
   classesUnderTest.add(ClassExtendingAbstractClass.class);
   classesUnderTest.add(AbstractClassClassExtendingInterfaceUnderTestWithAddedAnnotations.class);
   classesUnderTest.add(InterfaceUnderTestOne.class);
   TestsMetadata metadatas = builder.build(classesUnderTest, testClasses, true);
   assertThat(metadatas.getTestClassesFor(ClassExtendingAbstractClass.class, true).size(), is(2));
   assertThat(
       metadatas.getTestClassesFor(ClassExtendingAbstractClass.class, true),
       hasItems(
           equalTo(TEST_CLASS_ONE_ON_INTERFACE_METADATA),
           equalTo(TEST_CLASS_TWO_ON_INTERFACE_METADATA)));
   assertThat(metadatas.getTestMethodsFor(ClassExtendingAbstractClass.class, true).size(), is(4));
   assertThat(
       metadatas
           .getTestClassesFor(
               AbstractClassClassExtendingInterfaceUnderTestWithAddedAnnotations.class, true)
           .size(),
       is(2));
   assertThat(metadatas.getTestClassesFor(InterfaceUnderTestOne.class, true).size(), is(1));
 }
 @Test
 public void buildShouldRunClassUnderTestOneAnnotationWithWrongClassName() {
   List<Class<?>> testClasses = Arrays.asList(TestClassOne.class, TestClassTwo.class);
   AnnotationBasedMetadataBuilder builder = new AnnotationBasedMetadataBuilder();
   List<Class<?>> classesUnderTest = new LinkedList<Class<?>>();
   classesUnderTest.add(ClassUnderTestOneAnnotationWithWrongClassName.class);
   TestsMetadata metadatas = builder.build(classesUnderTest, testClasses);
   // no metadata directly on class
   assertThat(
       metadatas
           .getTestClassesFor(ClassUnderTestOneAnnotationWithWrongClassName.class, false)
           .size(),
       is(1));
   // metadatas from methods
   ClassLinkMetadata testClassWrong =
       new ClassLinkMetadata(status, "it.javalinux.testedby.testsupport.TestClassWrong");
   assertThat(
       metadatas.getTestClassesFor(ClassUnderTestOneAnnotationWithWrongClassName.class, false),
       hasItems(equalTo(testClassWrong)));
   assertThat(
       metadatas
           .getTestClassesFor(ClassUnderTestOneAnnotationWithWrongClassName.class, false)
           .iterator()
           .next()
           .getStatus()
           .isValid(),
       is(false));
 }
  @Test
  public void shouldRunClassUnderTestOneAnnotationAndListOnMethods() throws Exception {
    List<Class<?>> testClasses = Arrays.asList(TestClassOne.class, TestClassTwo.class);
    AnnotationBasedMetadataBuilder builder = new AnnotationBasedMetadataBuilder();
    List<Class<?>> classesUnderTest = new LinkedList<Class<?>>();
    classesUnderTest.add(ClassUnderTestOneAnnotationAndListOnMethods.class);
    TestsMetadata metadatas = builder.build(classesUnderTest, testClasses);
    Method methodOne = ClassUnderTestOneAnnotationAndListOnMethods.class.getMethod("methodOne");
    Method methodTwo = ClassUnderTestOneAnnotationAndListOnMethods.class.getMethod("methodTwo");

    assertThat(
        metadatas
            .getTestClassesFor(ClassUnderTestOneAnnotationAndListOnMethods.class, false)
            .size(),
        is(0));
    assertThat(
        metadatas.getTestClassesFor(ClassUnderTestOneAnnotationAndListOnMethods.class, true).size(),
        is(2));
    assertThat(
        metadatas.getTestClassesFor(ClassUnderTestOneAnnotationAndListOnMethods.class, true),
        hasItems(equalTo(TEST_CLASS_ONE_METADATA), equalTo(TEST_CLASS_TWO_METADATA)));

    assertThat(
        metadatas
            .getTestMethodsFor(ClassUnderTestOneAnnotationAndListOnMethods.class, methodOne)
            .size(),
        is(1));
    assertThat(
        metadatas.getTestMethodsFor(ClassUnderTestOneAnnotationAndListOnMethods.class, methodOne),
        hasItems(equalTo(TEST_METHOD_ONE_IN_CLASS_ONE)));

    assertThat(
        metadatas
            .getTestMethodsFor(ClassUnderTestOneAnnotationAndListOnMethods.class, methodTwo)
            .size(),
        is(3));
    assertThat(
        metadatas.getTestMethodsFor(ClassUnderTestOneAnnotationAndListOnMethods.class, methodTwo),
        hasItems(
            equalTo(TEST_METHOD_TWO_IN_CLASS_ONE),
            equalTo(TEST_METHOD_ONE_IN_CLASS_TWO),
            equalTo(TEST_METHOD_TWO_IN_CLASS_TWO)));

    assertThat(
        metadatas
            .getTestMethodsFor(ClassUnderTestOneAnnotationAndListOnMethods.class, false)
            .size(),
        is(0));
    assertThat(
        metadatas.getTestMethodsFor(ClassUnderTestOneAnnotationAndListOnMethods.class, true).size(),
        is(4));
    assertThat(
        metadatas.getTestMethodsFor(ClassUnderTestOneAnnotationAndListOnMethods.class, true),
        hasItems(
            equalTo(TEST_METHOD_ONE_IN_CLASS_ONE),
            equalTo(TEST_METHOD_TWO_IN_CLASS_ONE),
            equalTo(TEST_METHOD_ONE_IN_CLASS_TWO),
            equalTo(TEST_METHOD_TWO_IN_CLASS_TWO)));
  }
 @Test
 public void buildShouldNotChangePassedListsIfTheyAreNull() {
   List<Class<?>> testClasses = null;
   AnnotationBasedMetadataBuilder builder = new AnnotationBasedMetadataBuilder();
   List<Class<?>> classesUnderTest = null;
   builder.build(classesUnderTest, (Collection<ClassLinkMetadata>) null, testClasses);
   assertThat(testClasses, is(isNull()));
   assertThat(classesUnderTest, is(isNull()));
 }
 @Test
 public void buildShouldRunOnClassUnderTestOneAnnotationOnClass() {
   List<Class<?>> testClasses = Arrays.asList(TestClassOne.class, TestClassTwo.class);
   AnnotationBasedMetadataBuilder builder = new AnnotationBasedMetadataBuilder();
   List<Class<?>> classesUnderTest = new LinkedList<Class<?>>();
   classesUnderTest.add(ClassUnderTestOneAnnotationOnClass.class);
   TestsMetadata metadatas = builder.build(classesUnderTest, testClasses);
   assertThat(
       metadatas.getTestMethodsFor(ClassUnderTestOneAnnotationOnClass.class, false).size(), is(1));
   assertThat(
       metadatas.getTestMethodsFor(ClassUnderTestOneAnnotationOnClass.class, false),
       hasItems(equalTo(TEST_METHOD_ONE_IN_CLASS_ONE)));
 }
 @Test
 public void buildShouldRunOnClassUnderTestWithAllAnnotationsAndWrongTestClassesAndMethods() {
   List<Class<?>> testClasses = Arrays.asList(TestClassOne.class, TestClassTwo.class);
   AnnotationBasedMetadataBuilder builder = new AnnotationBasedMetadataBuilder();
   List<Class<?>> classesUnderTest = new LinkedList<Class<?>>();
   classesUnderTest.add(ClassUnderTestWithAllAnnotationsAndWrongTestClassesAndMethods.class);
   TestsMetadata metadatas = builder.build(classesUnderTest, testClasses, true);
   assertThat(
       metadatas
           .getTestClassesFor(
               ClassUnderTestWithAllAnnotationsAndWrongTestClassesAndMethods.class, true)
           .size(),
       is(1));
   assertThat(
       metadatas.getTestClassesFor(
           ClassUnderTestWithAllAnnotationsAndWrongTestClassesAndMethods.class, true),
       hasItems(equalTo(TEST_CLASS_TWO_METADATA)));
 }
 @Test
 public void buildShouldRunClassUnderTestOneAnnotationOnWrongMethod() {
   List<Class<?>> testClasses = Arrays.asList(TestClassOne.class, TestClassTwo.class);
   AnnotationBasedMetadataBuilder builder = new AnnotationBasedMetadataBuilder();
   List<Class<?>> classesUnderTest = new LinkedList<Class<?>>();
   classesUnderTest.add(ClassUnderTestOneAnnotationOnWrongMethod.class);
   TestsMetadata metadatas = builder.build(classesUnderTest, testClasses);
   // no metadata directly on class
   assertThat(
       metadatas.getTestClassesFor(ClassUnderTestOneAnnotationOnWrongMethod.class, true).size(),
       is(1));
   assertThat(
       metadatas.getTestMethodsFor(ClassUnderTestOneAnnotationOnWrongMethod.class, true).size(),
       is(1));
   assertThat(
       metadatas
           .getTestMethodsFor(ClassUnderTestOneAnnotationOnWrongMethod.class, true)
           .get(0)
           .getStatus()
           .isValid(),
       is(false));
 }
 @Test
 public void buildShouldRunOnClassExtendingAbstractClassSettingCorrectStatuses() {
   List<Class<?>> testClasses =
       Arrays.asList(
           TestClassOne.class,
           TestClassTwo.class,
           TestClassOnInterfaceOne.class,
           TestClassOnInterfaceTwo.class);
   AnnotationBasedMetadataBuilder builder = new AnnotationBasedMetadataBuilder();
   List<Class<?>> classesUnderTest = new LinkedList<Class<?>>();
   classesUnderTest.add(ClassExtendingAbstractClass.class);
   classesUnderTest.add(AbstractClassClassExtendingInterfaceUnderTestWithAddedAnnotations.class);
   classesUnderTest.add(InterfaceUnderTestOne.class);
   TestsMetadata metadatas = builder.build(classesUnderTest, testClasses, true);
   assertThat(metadatas.getTestMethodsFor(ClassExtendingAbstractClass.class, true).size(), is(4));
   for (ClassLinkMetadata classLink :
       metadatas.getTestClassesFor(ClassExtendingAbstractClass.class, true)) {
     assertThat(classLink.getStatus().isOnAbstract(), is(false));
   }
   assertThat(
       metadatas
           .getTestClassesFor(
               AbstractClassClassExtendingInterfaceUnderTestWithAddedAnnotations.class, true)
           .size(),
       is(2));
   for (ClassLinkMetadata classLink :
       metadatas.getTestClassesFor(
           AbstractClassClassExtendingInterfaceUnderTestWithAddedAnnotations.class, true)) {
     assertThat(classLink.getStatus().isOnAbstract(), is(true));
   }
   assertThat(metadatas.getTestClassesFor(InterfaceUnderTestOne.class, true).size(), is(1));
   for (ClassLinkMetadata classLink :
       metadatas.getTestClassesFor(InterfaceUnderTestOne.class, true)) {
     assertThat(classLink.getStatus().isOnAbstract(), is(true));
   }
 }