anchor.diff:  
     /// Many of the tests don't play well on windows. Simply skip them.
     final bool skipOnWindows;
  +
  +  /// Test with `core.ignoreCase` set to `true`, `false` or both (if `null`).
  +  final bool ignoreCase;
   
     TestData(
       this.name,
  
positive.code:     this.paths, {
      this.hasWarning = false,
      this.skipOnWindows = false,
    });
  
    TestData.single(
  
negative.code:         workingDirectory: workingDirectory);
    }
  
    group('git', () {
      Directory tmp;
  
      setUpAll(() async {
        tmp = await Directory.systemTemp.createTemp('package-ignore-test-');
  
        final ret = runGit(['init'], workingDirectory: tmp.path);
        expect(ret.exitCode, equals(0),
            reason:
                'Running "git init" failed. StdErr: ${ret.stderr} StdOut: ${ret.stdout}');
      });
  
      tearDownAll(() async {
        await tmp.delete(recursive: true);
        tmp = null;
      });
  
      tearDown(() async {
        runGit(['clean', '-f', '-d', '-x'], workingDirectory: tmp.path);
      });
  
      void _testIgnorePath(
        TestData c,
        String path,
        bool expected,
        bool ignoreCase,
      ) {
        final casing = 'with ignoreCase = $ignoreCase';
        final result = expected ? 'IGNORED' : 'NOT ignored';
        test('${c.name}: git check-ignore "$path" is $result $casing', () async {
          expect(
            runGit(
              ['config', '--local', 'core.ignoreCase', ignoreCase.toString()],
              workingDirectory: tmp.path,
            ).exitCode,
            anyOf(0, 1),
            reason: 'Running "git config --local core.ignoreCase ..." failed',
          );
  
          for (final directory in c.patterns.keys) {
            final resolvedDirectory =
                directory == '' ? tmp.uri : tmp.uri.resolve(directory + '/');
            Directory.fromUri(resolvedDirectory).createSync(recursive: true);
            final gitIgnore =
                File.fromUri(resolvedDirectory.resolve('.gitignore'));
            gitIgnore.writeAsStringSync(
              c.patterns[directory].join('\n') + '\n',
            );
          }
          final process = runGit(
              ['-C', tmp.path, 'check-ignore', '--no-index', path],
              workingDirectory: tmp.path);
          expect(process.exitCode, anyOf(0, 1),
              reason: 'Running "git check-ignore" failed');
          final ignored = process.exitCode == 0;
          if (expected != ignored) {
            if (expected) {
              fail('Expected "$path" to be ignored, it was NOT!');
            }
            fail('Expected "$path" to NOT be ignored, it was IGNORED!');
          }
        },
            skip: Platform.isMacOS || // System `git` on mac has issues...
                c.skipOnWindows && Platform.isWindows);
      }
  
      for (final c in testData) {
        c.paths.forEach((path, expected) {
          if (c.ignoreCase == null) {
            _testIgnorePath(c, path, expected, false);
            _testIgnorePath(c, path, expected, true);
          } else {
            _testIgnorePath(c, path, expected, c.ignoreCase);
          }
        });
      }
    });
  }
  
  class TestData {
  