public void run()

in tools/device_broker/java/com/google/android/apps/common/testing/suite/dex/DumpUtils.java [443:542]
89 lines of code
22 McCabe index (conditional complexity)

    public void run() {
      checkState(null != classData, "run twice?");
      Optional<TestRelatedClassData> myParentData = null;
      try {
        myParentData = myParentFutureTestData.get();
      } catch (InterruptedException ie) {
        throw new RuntimeException(ie);
      } catch (ExecutionException ee) {
        throwIfUnchecked(ee.getCause());
        throw new RuntimeException(ee.getCause());
      }
      if (myParentData.isPresent() && myParentData.get().defaultAnnotationData.isPresent()) {
        // parent is default annotation data.
        myFutureTestData.set(Optional.<TestRelatedClassData>absent());
        return;
      }

      if (!myParentData.isPresent() && !hasJUnit4TestData(classData)) {
        // nope - not a j4 test, not a j3 test.
        myFutureTestData.set(Optional.<TestRelatedClassData>absent());
        return;
      }
      TestRelatedClassData parentData = myParentData.or(new TestRelatedClassData(false));
      TestRelatedClassData myTestRelatedData =
          new TestRelatedClassData(parentData.descendsFromJUnit3TestCase);
      if (classData.isUiTest() || parentData.isUiTest) {
        myTestRelatedData.isUiTest = true;
      }

      List<AnnotationPb> myAggregatedClassAnnotations =
          Lists.newArrayList(classData.getAnnotations());
      Set<String> myAnnotationClassNames = Sets.newHashSet();
      for (AnnotationPb anno : myAggregatedClassAnnotations) {
        myAnnotationClassNames.add(anno.getClassName());
      }
      if (parentData.aggregatedClassAnnotations.isPresent()) {
        for (AnnotationPb parentAnno : parentData.aggregatedClassAnnotations.get()) {
          if (!myAnnotationClassNames.contains(parentAnno.getClassName())) {
            myAggregatedClassAnnotations.add(parentAnno);
          }
        }
      }

      myTestRelatedData.aggregatedClassAnnotations = Optional.of(myAggregatedClassAnnotations);

      Map<String, MethodData> myAggregatedTestMethods = Maps.newHashMap();
      myAggregatedTestMethods.putAll(
          FluentIterable.from(classData.getMethods())
              .filter(Predicates.or(IS_J3_TEST_METHOD, IS_J4_TEST_METHOD))
              .uniqueIndex(EXTRACT_METHOD_NAME));

      if (parentData.aggregatedTestMethods.isPresent()) {
        // merge the parent test methods to the sub class test methods
        // append any annotation present on the parent method to our method.

        for (MethodData parentMeth : parentData.aggregatedTestMethods.get()) {
          MethodData myOverride = myAggregatedTestMethods.get(parentMeth.getMethodName());
          if (null == myOverride) {
            myAggregatedTestMethods.put(parentMeth.getMethodName(), parentMeth);
          } else {
            Set<String> myOverrideAnnotationNames = Sets.newHashSet();
            for (AnnotationPb myOverrideAnnotation : myOverride.getAnnotations()) {
              myOverrideAnnotationNames.add(myOverrideAnnotation.getClassName());
            }
            List<AnnotationPb> myAggregatedAnnotations =
                Lists.newArrayList(myOverride.getAnnotations());
            for (AnnotationPb parentAnno : parentMeth.getAnnotations()) {
              if (!myOverrideAnnotationNames.contains(parentAnno.getClassName())) {
                myAggregatedAnnotations.add(parentAnno);
              }
            }
            if (myAggregatedAnnotations.size() != myOverride.getAnnotations().size()) {
              MethodData.MethodBuilder builder = myOverride.toBuilder().clearAnnotations();
              for (AnnotationPb anno : myAggregatedAnnotations) {
                builder.addAnnotation(anno);
              }
              myOverride = builder.build();
              myAggregatedTestMethods.put(myOverride.getMethodName(), myOverride);
            }
          }
        }
      }
      myTestRelatedData.aggregatedTestMethods =
          Optional.<List<MethodData>>of(Lists.newArrayList(myAggregatedTestMethods.values()));

      if (!classData.isAbstract()) {
        myTestRelatedData.executableTests =
            Optional.<List<InfoPb>>of(
                FluentIterable.from(myTestRelatedData.aggregatedTestMethods.get())
                    .filter(runnerFilter(myTestRelatedData))
                    .transform(
                        new MethodToTestInfoConvertor(
                            classData,
                            myTestRelatedData.aggregatedClassAnnotations.get(),
                            myTestRelatedData.isUiTest))
                    .toList());
      }
      classData = null;
      myFutureTestData.set(Optional.<TestRelatedClassData>of(myTestRelatedData));
    }