anchor.diff:      testCase(
           thatWhen: 'no projects provided',
           asProvidedBy: () => [],
  -        expectTheseInvocations: () => []);
  +        expectTheseInvocations: (_) => []);
  +
  +    testCase(
  +        thatWhen: 'a single project has no dependencies',
  +        asProvidedBy: () => [aProject('project1')],
  +        expectTheseInvocations: (Iterable<Project> projects) =>
  +            [new TestProcessInvocation(projects.first, const [])]);
  +
  +//    group('for one project with no dependencies', () {
  +//      MockProject project1;
  +//
  +//      setUp(() {
  +//        project1 = new MockProject('project1', new PubSpec());
  +//        scheduleForProjects([project1]);
  +//      });
  +//
  +//      test('calls processor once', () {
  +//        schedule(() => expect(processor.invocations, hasLength(1)));
  +//      });
  +//
  +//      test('calls processor once with expected project', () {
  +//        schedule(() =>
  +//            expect(processor.invocations.first.project, equals(project1)));
  +//      });
  +//
  +//      test('calls processor once with no dependencies', () {
  +//        schedule(
  +//            () => expect(processor.invocations.first.dependencies, isEmpty));
  +//      });
  +//    });
  +
     });
   }
   
  
positive.code:   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
  }
  
  foo() {
    testCase(
        thatWhen: 'no projects provided',
        asProvidedBy: () => [],
        expectTheseInvocations: () => []);
  }
  
  testCase({String thatWhen, Iterable<Project> asProvidedBy(),
      List<TestProcessInvocation> expectTheseInvocations()}) {
    TestProcessor processor;
  
    scheduleForProjects(Iterable<Project> projects) {
      return schedule(() async {
        processor = new TestProcessor();
        final DependencyGraph graph = await getDependencyGraph(projects.toSet());
        return graph.depthFirst(processor);
      });
    }
  
    setUpForProjects(Iterable<Project> projects) {
      setUp(() => scheduleForProjects(projects));
    }
  
    group(thatWhen, () {
      setUpForProjects(asProvidedBy());
      TestProcessor.createTests(() => processor, expectTheseInvocations());
    });
  }
  
  awhen(String name, {Iterable<Project> withProjects()}) {}
  
  Project aproject(String name,
      {Iterable<PathReference> pathDependencies: const []}) {}
  
  class TestPrecondition {
    String description;
  
negative.code: import 'package:devops/src/pubspec/pubspec.dart';
  import 'dart:async';
  import 'package:devops/src/pubspec/dependency.dart';
  import 'package:stack_trace/stack_trace.dart';
  import 'package:logging/logging.dart';
  
  main() async {
    Logger.root.level = Level.ALL;
    Logger.root.onRecord.listen(print);
    hierarchicalLoggingEnabled = true;
  
    Chain.capture(() {
      runDaTests();
    }, onError: (error, stackChain) {
      print("Caught error $error\n"
          "${stackChain.terse}");
    });
  }
  
  runDaTests() {
    TestProcessor processor;
  
    group('depthFirst', () {
  