diff --git a/pkgs/test_analyzer_plugin/CHANGELOG.md b/pkgs/test_analyzer_plugin/CHANGELOG.md
new file mode 100644
index 000000000..3624f43d5
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/CHANGELOG.md
@@ -0,0 +1,27 @@
+## 0.1.0
+
+- Initial release
+
+- Available rules:
+  - `test_in_test`: Report a warning when a `test`, `group`, `setUp`, `setUpAll`,
+    `tearDown`, or `tearDownAll` is declared inside a `test`, `setUp`, `setUpAll`,
+    `tearDown`, or `tearDownAll` declaration.
+
+  - `non_nullable_is_not_null`: Report a warning when a non-nullable value is
+    matched against `isNotNull` or `isNull`.
+
+  - `use_contains_matcher`: Report a warning when an `expect` expectation of
+    `true`, `false`, `isTrue`, or `isFalse` is paired with a `.contains` method
+    call on an actual value (maybe wrapped with a `!`). Instead, the `contains`
+    Matcher (maybe wrapped with the `isNot()` Matcher) should be used.
+
+  - `use_is_empty_matcher`: Report a warning when an `expect` expectation of
+    `true`, `false`, `isTrue`, or `isFalse` is paired with an `.isEmpty` or
+    `.isNotEmpty` property access on an actual value. Instead, the `isEmpty` or
+    `isNotEmpty` Matcher should be used.
+
+  - `test_body_goes_last`: Report a lint when the body argument of a `test` or
+    `group` is not last.
+
+- Quick fixes
+  - Offer a quick fix in the IDE for `test_in_test`.
diff --git a/pkgs/test_analyzer_plugin/LICENSE b/pkgs/test_analyzer_plugin/LICENSE
new file mode 100644
index 000000000..2b76736b4
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/LICENSE
@@ -0,0 +1,27 @@
+Copyright 2025, the Dart project authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google LLC nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pkgs/test_analyzer_plugin/README.md b/pkgs/test_analyzer_plugin/README.md
new file mode 100644
index 000000000..f60560f15
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/README.md
@@ -0,0 +1,32 @@
+# test_analyzer_plugin
+
+This package is an analyzer plugin that provides additional static analysis for
+usage of the test package.
+
+This analyzer plugin provides the following additional analysis:
+
+* Report a warning when a `test`, `group`, `setUp`, `setUpAll`, `tearDown`, or
+  `tearDownAll` is declared inside a `test`, `setUp`, `setUpAll`, `tearDown`, or
+  `tearDownAll` declaration. This can _sometimes_ be detected at runtime, but
+  it's more convenient to report this warning statically.
+
+* Report a warning when a non-nullable value is matched against `isNotNull` or
+  `isNull`.
+
+* Report a warning when an `expect` expectation of `true`, `false`, `isTrue`, or
+  `isFalse` is paired with a `.contains` method call on an actual value (maybe
+  wrapped with a `!`). Instead, the `contains` Matcher (maybe wrapped with the
+  `isNot()` Matcher) should be used. This Matcher yields meaningful failure
+  messages.
+
+* Report a warning when an `expect` expectation of `true`, `false`, `isTrue`,
+  or `isFalse` is paired with an `.isEmpty` or `.isNotEmpty` property access on
+  an actual value. Instead, the `isEmpty` or `isNotEmpty` Matcher should be
+  used. These Matchers yield meaningful failure messages.
+
+* Report a lint when the body argument of a `test` or `group` is not last. Lint
+  rules are not enabled by default and must be actively enabled in analysis
+  options.
+
+* Offer a quick fix in the IDE for the above warning, which moves the violating
+  `test` or `group` declaration below the containing `test` declaration.
diff --git a/pkgs/test_analyzer_plugin/lib/main.dart b/pkgs/test_analyzer_plugin/lib/main.dart
new file mode 100644
index 000000000..4bedf4ed2
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/lib/main.dart
@@ -0,0 +1,43 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analysis_server_plugin/plugin.dart';
+import 'package:analysis_server_plugin/registry.dart';
+
+import 'src/fixes.dart';
+import 'src/rules/non_nullable_is_not_null_rule.dart';
+import 'src/rules/test_body_goes_last_rule.dart';
+import 'src/rules/test_in_test_rule.dart';
+import 'src/rules/use_contains_matcher_rule.dart';
+import 'src/rules/use_is_empty_matcher.dart';
+
+final plugin = TestPackagePlugin();
+
+class TestPackagePlugin extends Plugin {
+  @override
+  String get name => 'Test package plugin';
+
+  @override
+  void register(PluginRegistry registry) {
+    registry.registerWarningRule(TestInTestRule());
+    registry.registerFixForRule(
+      TestInTestRule.code,
+      MoveBelowEnclosingTestCall.new,
+    );
+
+    registry.registerWarningRule(NonNullableIsNotNullRule());
+    registry.registerWarningRule(UseContainsMatcherRule());
+    registry.registerWarningRule(UseIsEmptyMatcherRule());
+    registry.registerLintRule(TestBodyGoesLastRule());
+    // Should we register a fix for this rule? The only automatic fix I can
+    // think of would be to delete the entire statement:
+    // `expect(a, isNotNull);` or `expect(a, isNull);`.
+
+    // TODO(srawlins): More rules to catch:
+    // * `expect(7, contains(6))` - should only use `hasLength` with `Iterable`,
+    //   `Map`, or `String`.
+    // * `expect(7, hasLength(3))` - should only use `hasLength` with
+    //   `Iterable`, `Map`, or `String`.
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/lib/src/fixes.dart b/pkgs/test_analyzer_plugin/lib/src/fixes.dart
new file mode 100644
index 000000000..f2d36f8a1
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/lib/src/fixes.dart
@@ -0,0 +1,61 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analysis_server_plugin/edit/dart/correction_producer.dart';
+import 'package:analysis_server_plugin/edit/dart/dart_fix_kind_priority.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
+import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
+import 'package:analyzer_plugin/utilities/range_factory.dart';
+
+import 'utilities.dart';
+
+class MoveBelowEnclosingTestCall extends ResolvedCorrectionProducer {
+  static const _moveBelowEnclosingTestCallKind = FixKind(
+    'dart.fix.moveBelowEnclosingTestCall',
+    DartFixKindPriority.standard,
+    "Move below the enclosing 'test' call",
+  );
+
+  MoveBelowEnclosingTestCall({required super.context});
+
+  @override
+  CorrectionApplicability get applicability =>
+      // This fix may break code by moving references to variables away from the
+      // scope in which they are declared.
+      CorrectionApplicability.singleLocation;
+
+  @override
+  FixKind get fixKind => _moveBelowEnclosingTestCallKind;
+
+  @override
+  Future<void> compute(ChangeBuilder builder) async {
+    var methodCall = node;
+    if (methodCall is! MethodInvocation) return;
+    AstNode? enclosingTestCall = findEnclosingTestCall(methodCall);
+    if (enclosingTestCall == null) return;
+
+    if (enclosingTestCall.parent is ExpressionStatement) {
+      // Move the 'test' call to below the outer 'test' call _statement_.
+      enclosingTestCall = enclosingTestCall.parent!;
+    }
+
+    if (methodCall.parent is ExpressionStatement) {
+      // Move the whole statement (don't leave the semicolon dangling).
+      methodCall = methodCall.parent!;
+    }
+
+    await builder.addDartFileEdit(file, (builder) {
+      var indent = utils.getLinePrefix(enclosingTestCall!.offset);
+      var source = utils.getRangeText(range.node(methodCall));
+
+      // Move the source for `methodCall` wholsale to be just after `enclosingTestCall`.
+      builder.addDeletion(range.deletionRange(methodCall));
+      builder.addSimpleInsertion(
+        enclosingTestCall.end,
+        '$defaultEol$defaultEol$indent$source',
+      );
+    });
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart b/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart
new file mode 100644
index 000000000..7bdfaa0e3
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/lib/src/rules/non_nullable_is_not_null_rule.dart
@@ -0,0 +1,86 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/analysis_rule/analysis_rule.dart';
+import 'package:analyzer/analysis_rule/rule_context.dart';
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/type_system.dart';
+import 'package:analyzer/error/error.dart';
+
+import '../utilities.dart';
+
+class NonNullableIsNotNullRule extends MultiAnalysisRule {
+  static const LintCode nonNullableIsNotNullCode = LintCode(
+    'non_nullable_is_not_null',
+    'Do not check whether a non-nullable value isNotNull',
+    correctionMessage: 'Try changing the expectation, or removing it',
+  );
+
+  static const LintCode nonNullableIsNullCode = LintCode(
+    'non_nullable_is_null',
+    'Do not check whether a non-nullable value isNull',
+    correctionMessage: 'Try changing the expectation, or removing it',
+  );
+
+  NonNullableIsNotNullRule()
+    : super(
+        name: 'non_nullable_is_not_null',
+        description:
+            "Non-nullable values will always pass an 'isNotNull' "
+            "expectation and never pass an 'isNull' expectation.",
+      );
+
+  @override
+  List<LintCode> get diagnosticCodes => [
+    nonNullableIsNotNullCode,
+    nonNullableIsNullCode,
+  ];
+
+  @override
+  void registerNodeProcessors(
+    RuleVisitorRegistry registry,
+    RuleContext context,
+  ) {
+    var visitor = _Visitor(this, context.typeSystem);
+    registry.addMethodInvocation(this, visitor);
+  }
+}
+
+class _Visitor extends SimpleAstVisitor<void> {
+  final MultiAnalysisRule rule;
+
+  final TypeSystem typeSystem;
+
+  _Visitor(this.rule, this.typeSystem);
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    if (!node.methodName.isExpect) return;
+
+    if (node.argumentList.arguments case [
+      var actual,
+      SimpleIdentifier matcher,
+    ]) {
+      var actualType = actual.staticType;
+      if (actualType == null) return;
+      if (typeSystem.isNonNullable(actualType)) {
+        if (matcher.isNotNull) {
+          // The actual value will always match this matcher.
+          rule.reportAtNode(
+            matcher,
+            diagnosticCode: NonNullableIsNotNullRule.nonNullableIsNotNullCode,
+          );
+        } else if (matcher.isNull) {
+          // The actual value will never match this matcher.
+          rule.reportAtNode(
+            matcher,
+            diagnosticCode: NonNullableIsNotNullRule.nonNullableIsNullCode,
+          );
+        }
+      }
+    }
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/lib/src/rules/test_body_goes_last_rule.dart b/pkgs/test_analyzer_plugin/lib/src/rules/test_body_goes_last_rule.dart
new file mode 100644
index 000000000..34c9dc5ef
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/lib/src/rules/test_body_goes_last_rule.dart
@@ -0,0 +1,66 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/analysis_rule/analysis_rule.dart';
+import 'package:analyzer/analysis_rule/rule_context.dart';
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/error/error.dart';
+
+import '../utilities.dart';
+
+class TestBodyGoesLastRule extends AnalysisRule {
+  static const LintCode code = LintCode(
+    'test_body_goes_last',
+    "The body of a '{0}' should go after the other arguments",
+    correctionMessage:
+        "Try moving the body argument below the other '{0}' arguments",
+  );
+
+  TestBodyGoesLastRule()
+    : super(
+        name: 'test_body_goes_last',
+        description:
+            'The body of a test or group should go after the other arguments',
+      );
+
+  @override
+  LintCode get diagnosticCode => code;
+
+  @override
+  void registerNodeProcessors(
+    RuleVisitorRegistry registry,
+    RuleContext context,
+  ) {
+    var visitor = _Visitor(this);
+    registry.addMethodInvocation(this, visitor);
+  }
+}
+
+class _Visitor extends SimpleAstVisitor<void> {
+  final AnalysisRule rule;
+
+  _Visitor(this.rule);
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    if (!node.methodName.isTest && !node.methodName.isGroup) return;
+
+    final arguments = node.argumentList.arguments;
+
+    for (var i = 0; i < arguments.length; i++) {
+      final argument = arguments[i];
+      if (argument.correspondingParameter?.name == 'body') {
+        if (i == arguments.length - 1) return;
+        final errorNode = argument is FunctionExpression
+            ? argument.parameters
+            : argument;
+        rule.reportAtNode(errorNode, arguments: [node.methodName.name]);
+        // Do not keep iterating through the arguments.
+        return;
+      }
+    }
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart b/pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart
new file mode 100644
index 000000000..db7346c38
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/lib/src/rules/test_in_test_rule.dart
@@ -0,0 +1,60 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/analysis_rule/analysis_rule.dart';
+import 'package:analyzer/analysis_rule/rule_context.dart';
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/error/error.dart';
+
+import '../utilities.dart';
+
+class TestInTestRule extends AnalysisRule {
+  static const LintCode code = LintCode(
+    'test_in_test',
+    "Do not declare a 'test' or a 'group' inside a '{0}'",
+    correctionMessage: "Try moving 'test' or 'group' outside of '{0}'",
+  );
+
+  TestInTestRule()
+    : super(
+        name: 'test_in_test',
+        description:
+            'Tests and groups declared inside of a test are not properly '
+            'registered in the test framework.',
+      );
+
+  @override
+  LintCode get diagnosticCode => code;
+
+  @override
+  void registerNodeProcessors(
+    RuleVisitorRegistry registry,
+    RuleContext context,
+  ) {
+    var visitor = _Visitor(this);
+    registry.addMethodInvocation(this, visitor);
+  }
+}
+
+class _Visitor extends SimpleAstVisitor<void> {
+  final AnalysisRule rule;
+
+  _Visitor(this.rule);
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    if (!node.methodName.isTestOrGroupOrSetUpOrTearDown) return;
+
+    var enclosingTestOrSetUpOrTearDownCall =
+        findEnclosingTestOrSetUpOrTearDownCall(node);
+    if (enclosingTestOrSetUpOrTearDownCall != null) {
+      rule.reportAtNode(
+        node.methodName,
+        arguments: [enclosingTestOrSetUpOrTearDownCall.methodName.name],
+      );
+    }
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/lib/src/rules/use_contains_matcher_rule.dart b/pkgs/test_analyzer_plugin/lib/src/rules/use_contains_matcher_rule.dart
new file mode 100644
index 000000000..ca35c55fa
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/lib/src/rules/use_contains_matcher_rule.dart
@@ -0,0 +1,107 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/analysis_rule/analysis_rule.dart';
+import 'package:analyzer/analysis_rule/rule_context.dart';
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/type_system.dart';
+import 'package:analyzer/error/error.dart';
+
+import '../utilities.dart';
+
+class UseContainsMatcherRule extends MultiAnalysisRule {
+  static const LintCode useIsContainsCode = LintCode(
+    'use_contains_matcher',
+    "Use the 'contains' matcher.",
+  );
+
+  static const LintCode useIsNotAndContainsMatchersCode = LintCode(
+    'use_is_not_and_contains_matchers',
+    "Use the 'isNot' and 'contains' matchers.",
+  );
+
+  UseContainsMatcherRule()
+    : super(
+        name: 'use_is_empty_matcher',
+        description: "Use the built-in 'contains' matcher.",
+      );
+
+  @override
+  List<LintCode> get diagnosticCodes => [
+    useIsContainsCode,
+    useIsNotAndContainsMatchersCode,
+  ];
+
+  @override
+  void registerNodeProcessors(
+    RuleVisitorRegistry registry,
+    RuleContext context,
+  ) {
+    var visitor = _Visitor(this, context.typeSystem);
+    registry.addMethodInvocation(this, visitor);
+  }
+}
+
+class _Visitor extends SimpleAstVisitor<void> {
+  final MultiAnalysisRule rule;
+
+  final TypeSystem typeSystem;
+
+  _Visitor(this.rule, this.typeSystem);
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    if (!node.methodName.isExpect) return;
+
+    var arguments = node.argumentList.arguments;
+    if (arguments.isEmpty || arguments.length > 2) return;
+    var [actual, matcher] = arguments;
+
+    bool actualIsContains;
+    if (actual is MethodInvocation && actual.methodName.name == 'contains') {
+      actualIsContains = true;
+    } else if (actual is PrefixExpression &&
+        actual.operator.type == TokenType.BANG) {
+      var operand = actual.operand.unParenthesized;
+      if (operand is MethodInvocation &&
+          operand.methodName.name == 'contains') {
+        actualIsContains = false;
+      } else {
+        return;
+      }
+    } else {
+      return;
+    }
+
+    bool matcherValue;
+    if (matcher is BooleanLiteral) {
+      matcherValue = matcher.value;
+    } else if (matcher is SimpleIdentifier && matcher.isIsFalse) {
+      matcherValue = false;
+    } else if (matcher is SimpleIdentifier && matcher.isIsTrue) {
+      matcherValue = true;
+    } else {
+      return;
+    }
+
+    if (actualIsContains == matcherValue) {
+      // Either `expect(a.contains(...), isTrue|true)` or
+      // `expect(!a.contains(...), isFalse|false)`.
+      rule.reportAtNode(
+        matcher,
+        diagnosticCode: UseContainsMatcherRule.useIsContainsCode,
+      );
+    } else {
+      // Either `expect(a.contains(...), isFalse|false)` or
+      // `expect(!a.contains(...), isTrue|true)`.
+      rule.reportAtNode(
+        matcher,
+        diagnosticCode: UseContainsMatcherRule.useIsNotAndContainsMatchersCode,
+      );
+    }
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/lib/src/rules/use_is_empty_matcher.dart b/pkgs/test_analyzer_plugin/lib/src/rules/use_is_empty_matcher.dart
new file mode 100644
index 000000000..99035e53c
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/lib/src/rules/use_is_empty_matcher.dart
@@ -0,0 +1,111 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/analysis_rule/analysis_rule.dart';
+import 'package:analyzer/analysis_rule/rule_context.dart';
+import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/type_system.dart';
+import 'package:analyzer/error/error.dart';
+
+import '../utilities.dart';
+
+class UseIsEmptyMatcherRule extends MultiAnalysisRule {
+  static const LintCode useIsEmptyMatcherCode = LintCode(
+    'use_is_empty_matcher',
+    "Use the 'isEmpty' matcher.",
+  );
+
+  static const LintCode useIsNotEmptyMatcherCode = LintCode(
+    'use_is_not_empty_matcher',
+    "Use the 'isNotEmpty' matcher.",
+  );
+
+  UseIsEmptyMatcherRule()
+    : super(
+        name: 'use_is_empty_matcher',
+        description: "Use the built-in 'isEmpty' and 'isNotEmpty' matchers.",
+      );
+
+  @override
+  List<LintCode> get diagnosticCodes => [
+    useIsEmptyMatcherCode,
+    useIsNotEmptyMatcherCode,
+  ];
+
+  @override
+  void registerNodeProcessors(
+    RuleVisitorRegistry registry,
+    RuleContext context,
+  ) {
+    var visitor = _Visitor(this, context.typeSystem);
+    registry.addMethodInvocation(this, visitor);
+  }
+}
+
+class _Visitor extends SimpleAstVisitor<void> {
+  final MultiAnalysisRule rule;
+
+  final TypeSystem typeSystem;
+
+  _Visitor(this.rule, this.typeSystem);
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    if (!node.methodName.isExpect) return;
+
+    var arguments = node.argumentList.arguments;
+    if (arguments.isEmpty || arguments.length > 2) return;
+    var [actual, matcher] = arguments;
+
+    bool actualIsIsEmpty;
+    if (actual is PrefixedIdentifier) {
+      if (actual.identifier.name == 'isEmpty') {
+        actualIsIsEmpty = true;
+      } else if (actual.identifier.name == 'isNotEmpty') {
+        actualIsIsEmpty = false;
+      } else {
+        return;
+      }
+    } else if (actual is PropertyAccess) {
+      if (actual.propertyName.name == 'isEmpty') {
+        actualIsIsEmpty = true;
+      } else if (actual.propertyName.name == 'isNotEmpty') {
+        actualIsIsEmpty = false;
+      } else {
+        return;
+      }
+    } else {
+      return;
+    }
+
+    bool matcherValue;
+    if (matcher is BooleanLiteral) {
+      matcherValue = matcher.value;
+    } else if (matcher is SimpleIdentifier && matcher.isIsFalse) {
+      matcherValue = false;
+    } else if (matcher is SimpleIdentifier && matcher.isIsTrue) {
+      matcherValue = true;
+    } else {
+      return;
+    }
+
+    if (actualIsIsEmpty == matcherValue) {
+      // Either `expect(a.isEmpty, isTrue|true)` or
+      // `expect(a.isNotEmpty, isFalse|false)`.
+      rule.reportAtNode(
+        matcher,
+        diagnosticCode: UseIsEmptyMatcherRule.useIsEmptyMatcherCode,
+      );
+    } else {
+      // Either `expect(a.isEmpty, isFalse|false)` or
+      // `expect(a.isNotEmpty, isTrue|true)`.
+      rule.reportAtNode(
+        matcher,
+        diagnosticCode: UseIsEmptyMatcherRule.useIsNotEmptyMatcherCode,
+      );
+    }
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/lib/src/utilities.dart b/pkgs/test_analyzer_plugin/lib/src/utilities.dart
new file mode 100644
index 000000000..77fced0f7
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/lib/src/utilities.dart
@@ -0,0 +1,137 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/dart/ast/ast.dart';
+
+/// Finds an enclosing call to the 'test' function, if there is one.
+MethodInvocation? findEnclosingTestCall(MethodInvocation node) {
+  var ancestor = node.parent?.thisOrAncestorOfType<MethodInvocation>();
+  while (ancestor != null) {
+    if (ancestor.methodName.isTest) {
+      return ancestor;
+    }
+    ancestor = ancestor.parent?.thisOrAncestorOfType<MethodInvocation>();
+  }
+  return null;
+}
+
+/// Finds an enclosing call to the 'test', 'setUp', 'setUpAll', 'tearDown', or
+/// 'tearDownAll' function if there is one.
+MethodInvocation? findEnclosingTestOrSetUpOrTearDownCall(
+  MethodInvocation node,
+) {
+  var ancestor = node.parent?.thisOrAncestorOfType<MethodInvocation>();
+  while (ancestor != null) {
+    var methodName = ancestor.methodName;
+    if (methodName.isTest ||
+        methodName.name == 'setUp' ||
+        methodName.name == 'setUpAll' ||
+        methodName.name == 'tearDown' ||
+        methodName.name == 'tearDownAll') {
+      if (methodName.isFromTestCore) {
+        return ancestor;
+      }
+    }
+    ancestor = ancestor.parent?.thisOrAncestorOfType<MethodInvocation>();
+  }
+  return null;
+}
+
+extension SimpleIdentifierExtension on SimpleIdentifier {
+  /// Whether this identifier represents the 'test', 'group', 'setUp',
+  /// 'setUpAll', 'tearDown', or 'tearDownAll' function from the 'test_core'
+  /// package.
+  bool get isTestOrGroupOrSetUpOrTearDown {
+    final element = this.element;
+    if (element == null) return false;
+    if (element.name != 'test' &&
+        element.name != 'group' &&
+        element.name != 'setUp' &&
+        element.name != 'setUpAll' &&
+        element.name != 'tearDown' &&
+        element.name != 'tearDownAll') {
+      return false;
+    }
+    return element.library?.uri.path.startsWith('test_core/') ?? false;
+  }
+
+  /// Whether this identifier represents the 'test', 'setUp', 'setUpAll',
+  /// 'tearDown', or 'tearDownAll' function from the 'test_core' package.
+  bool get isTestOrSetUpOrTearDown {
+    final element = this.element;
+    if (element == null) return false;
+    if (element.name != 'test' &&
+        element.name != 'setUp' &&
+        element.name != 'setUpAll' &&
+        element.name != 'tearDown' &&
+        element.name != 'tearDownAll') {
+      return false;
+    }
+    return isFromTestCore;
+  }
+
+  /// Whether this identifier represents the 'test' function from the
+  /// 'test_core' package.
+  bool get isTest {
+    final element = this.element;
+    if (element == null) return false;
+    return element.name == 'test' && isFromTestCore;
+  }
+
+  /// Whether this identifier represents the 'group' function from the
+  /// 'test_core' package.
+  bool get isGroup {
+    final element = this.element;
+    if (element == null) return false;
+    return element.name == 'group' && isFromTestCore;
+  }
+
+  bool get isFromTestCore =>
+      element?.library?.uri.path.startsWith('test_core/') ?? false;
+
+  /// Whether this identifier represents the 'expect' function from the
+  /// 'matcher' package.
+  bool get isExpect {
+    final element = this.element;
+    if (element == null) return false;
+    if (element.name != 'expect') return false;
+    return element.library?.uri.path.startsWith('matcher/') ?? false;
+  }
+
+  /// Whether this identifier represents the 'isFalse' matcher from the
+  /// 'matcher' package.
+  bool get isIsFalse {
+    final element = this.element;
+    if (element == null) return false;
+    if (element.name != 'isFalse') return false;
+    return element.library?.uri.path.startsWith('matcher/') ?? false;
+  }
+
+  /// Whether this identifier represents the 'isTrue' matcher from the
+  /// 'matcher' package.
+  bool get isIsTrue {
+    final element = this.element;
+    if (element == null) return false;
+    if (element.name != 'isTrue') return false;
+    return element.library?.uri.path.startsWith('matcher/') ?? false;
+  }
+
+  /// Whether this identifier represents the 'isNotNull' constant from the
+  /// 'matcher' package.
+  bool get isNotNull {
+    final element = this.element;
+    if (element == null) return false;
+    if (element.name != 'isNotNull') return false;
+    return element.library?.uri.path.startsWith('matcher/') ?? false;
+  }
+
+  /// Whether this identifier represents the 'isNull' constant from the
+  /// 'matcher' package.
+  bool get isNull {
+    final element = this.element;
+    if (element == null) return false;
+    if (element.name != 'isNull') return false;
+    return element.library?.uri.path.startsWith('matcher/') ?? false;
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/pubspec.yaml b/pkgs/test_analyzer_plugin/pubspec.yaml
new file mode 100644
index 000000000..5183c5ebd
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/pubspec.yaml
@@ -0,0 +1,18 @@
+name: test_analyzer_plugin
+description: An analyzer plugin to report improper usage of the test package.
+repository: https://github.com/dart-lang/test/tree/master/pkgs/test_core
+issue_tracker: https://github.com/dart-lang/test/issues?q=is%3Aissue+is%3Aopen
+version: 0.1.0
+
+environment:
+  sdk: ^3.10.0
+
+dependencies:
+  analysis_server_plugin: ^0.3.0
+  analyzer: ^9.0.0
+  analyzer_plugin: ^0.13.5
+
+dev_dependencies:
+  analyzer_testing: ^0.1.7
+  test: any
+  test_reflective_loader: any
diff --git a/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart b/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart
new file mode 100644
index 000000000..761ea752f
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/test/rules/non_nullable_is_not_null_test.dart
@@ -0,0 +1,79 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// ignore_for_file: non_constant_identifier_names
+
+import 'package:analyzer/utilities/package_config_file_builder.dart';
+import 'package:analyzer_testing/analysis_rule/analysis_rule.dart';
+import 'package:test_analyzer_plugin/src/rules/non_nullable_is_not_null_rule.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(NonNullableIsNotNullTest);
+  });
+}
+
+@reflectiveTest
+class NonNullableIsNotNullTest extends AnalysisRuleTest {
+  @override
+  void setUp() {
+    rule = NonNullableIsNotNullRule();
+    super.setUp();
+
+    var matcherPath = '/packages/matcher';
+    newFile('$matcherPath/lib/matcher.dart', '''
+void expect(dynamic actual, dynamic matcher) {}
+
+const isNotNull = 0;
+const isNull = 0;
+''');
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'matcher', rootPath: convertPath(matcherPath)),
+    );
+  }
+
+  void test_nullableValue_isNotNullMatcher() async {
+    await assertNoDiagnostics(r'''
+import 'package:matcher/matcher.dart';
+void f(String? p) {
+  expect(p, isNotNull);
+}
+''');
+  }
+
+  void test_nonNullableValue_isNotNullMatcher() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(123, isNotNull);
+}
+''',
+      [lint(64, 9)],
+    );
+  }
+
+  void test_nullableValue_isNullMatcher() async {
+    await assertNoDiagnostics(r'''
+import 'package:matcher/matcher.dart';
+void f(String? p) {
+  expect(p, isNull);
+}
+''');
+  }
+
+  void test_nonNullableValue_isNullMatcher() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(123, isNull);
+}
+''',
+      [lint(64, 6, name: 'non_nullable_is_null')],
+    );
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/test/rules/test_body_goes_last_test.dart b/pkgs/test_analyzer_plugin/test/rules/test_body_goes_last_test.dart
new file mode 100644
index 000000000..4686b9050
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/test/rules/test_body_goes_last_test.dart
@@ -0,0 +1,88 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// ignore_for_file: non_constant_identifier_names
+
+import 'package:analyzer_testing/analysis_rule/analysis_rule.dart';
+import 'package:test_analyzer_plugin/src/rules/test_body_goes_last_rule.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../with_test_package.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(TestBodyGoesLastTest);
+  });
+}
+
+@reflectiveTest
+class TestBodyGoesLastTest extends AnalysisRuleTest with WithTestPackage {
+  @override
+  void setUp() {
+    rule = TestBodyGoesLastRule();
+    super.setUp();
+  }
+
+  void test_groupBeforeSkip() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  group('description',
+    () {
+      // Test case.
+    },
+    skip: true,
+  );
+}
+''',
+      [lint(81, 2)],
+    );
+  }
+
+  void test_groupLast() async {
+    await assertNoDiagnostics(r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  group('description',
+    skip: true,
+    () {
+      // Test case.
+    },
+  );
+}
+''');
+  }
+
+  void test_testBeforeSkip() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  test('description',
+    () {
+      // Test case.
+    },
+    skip: true,
+  );
+}
+''',
+      [lint(80, 2)],
+    );
+  }
+
+  void test_testLast() async {
+    await assertNoDiagnostics(r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  test('description',
+    skip: true,
+    () {
+      // Test case.
+    },
+  );
+}
+''');
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/test/rules/test_in_test_test.dart b/pkgs/test_analyzer_plugin/test/rules/test_in_test_test.dart
new file mode 100644
index 000000000..7a93c911f
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/test/rules/test_in_test_test.dart
@@ -0,0 +1,179 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// ignore_for_file: non_constant_identifier_names
+
+import 'package:analyzer_testing/analysis_rule/analysis_rule.dart';
+import 'package:test_analyzer_plugin/src/rules/test_in_test_rule.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../with_test_package.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(TestInTestTest);
+  });
+}
+
+@reflectiveTest
+class TestInTestTest extends AnalysisRuleTest with WithTestPackage {
+  @override
+  void setUp() {
+    rule = TestInTestRule();
+    super.setUp();
+  }
+
+  void test_groupInGroup() async {
+    await assertNoDiagnostics(r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  group('one',
+    () {
+      group('two', () {});
+    },
+  );
+}
+''');
+  }
+
+  void test_groupInTest() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  test('one',
+    () {
+      group('two', () {});
+    },
+  );
+}
+''',
+      [lint(83, 5)],
+    );
+  }
+
+  void test_groupInSetUp() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  setUp(() {
+    group('two', () {});
+  });
+}
+''',
+      [lint(71, 5)],
+    );
+  }
+
+  void test_testInGroup() async {
+    await assertNoDiagnostics(r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  group('one',
+    () {
+      test('two', () {});
+    },
+  );
+}
+''');
+  }
+
+  void test_testInTest() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  test('one',
+    () {
+      test('two', () {});
+    },
+  );
+}
+''',
+      [lint(83, 4)],
+    );
+  }
+
+  void test_testInSetUp() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  setUp(() {
+    test('two', () {});
+  });
+}
+''',
+      [lint(71, 4)],
+    );
+  }
+
+  void test_testInSetUpAll() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  setUpAll(() {
+    test('two', () {});
+  });
+}
+''',
+      [lint(74, 4)],
+    );
+  }
+
+  void test_testInTearDown() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  tearDown(() {
+    test('two', () {});
+  });
+}
+''',
+      [lint(74, 4)],
+    );
+  }
+
+  void test_testInTearDownAll() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  tearDownAll(() {
+    test('two', () {});
+  });
+}
+''',
+      [lint(77, 4)],
+    );
+  }
+
+  void test_setUpInSetUp() async {
+    await assertDiagnostics(
+      r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  setUp(() {
+    setUp(() {});
+  });
+}
+''',
+      [lint(71, 5)],
+    );
+  }
+
+  void test_setUpInGroup() async {
+    await assertNoDiagnostics(r'''
+import 'package:test_core/test_core.dart';
+void f() {
+  group('', () {
+    setUp(() {});
+  });
+}
+''');
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/test/rules/use_contains_matcher_test.dart b/pkgs/test_analyzer_plugin/test/rules/use_contains_matcher_test.dart
new file mode 100644
index 000000000..2cd35dac9
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/test/rules/use_contains_matcher_test.dart
@@ -0,0 +1,150 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// ignore_for_file: non_constant_identifier_names
+
+import 'package:analyzer/utilities/package_config_file_builder.dart';
+import 'package:analyzer_testing/analysis_rule/analysis_rule.dart';
+import 'package:test_analyzer_plugin/src/rules/use_contains_matcher_rule.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(UseContainsMatcherTest);
+  });
+}
+
+@reflectiveTest
+class UseContainsMatcherTest extends AnalysisRuleTest {
+  @override
+  void setUp() {
+    rule = UseContainsMatcherRule();
+    super.setUp();
+
+    var matcherPath = '/packages/matcher';
+    newFile('$matcherPath/lib/matcher.dart', '''
+void expect(dynamic actual, dynamic matcher) {}
+
+const isNotNull = 0;
+const isNull = 0;
+
+const isEmpty = 0;
+const isFalse = 0;
+const isNotEmpty = 0;
+const isTrue = 0;
+
+class Matcher {}
+Matcher contains(Object? expected) => throw UnimplementedError();
+''');
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'matcher', rootPath: convertPath(matcherPath)),
+    );
+  }
+
+  void test_contains_false() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.contains(''), false);
+}
+''',
+      [lint(76, 5, name: 'use_is_not_and_contains_matchers')],
+    );
+  }
+
+  void test_contains_isFalse() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.contains(''), isFalse);
+}
+''',
+      [lint(76, 7, name: 'use_is_not_and_contains_matchers')],
+    );
+  }
+
+  void test_contains_isTrue() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.contains(''), isTrue);
+}
+''',
+      [lint(76, 6, name: 'use_contains_matcher')],
+    );
+  }
+
+  void test_contains_true() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.contains(''), true);
+}
+''',
+      [lint(76, 4, name: 'use_contains_matcher')],
+    );
+  }
+
+  void test_containsMatcher() async {
+    await assertNoDiagnostics(r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect('', contains(''));
+}
+''');
+  }
+
+  void test_notContainsParens_false() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(!(''.contains('')), false);
+}
+''',
+      [lint(79, 5, name: 'use_contains_matcher')],
+    );
+  }
+
+  void test_notContains_isFalse() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f(String s) {
+  expect(!s.contains(''), isFalse);
+}
+''',
+      [lint(84, 7, name: 'use_contains_matcher')],
+    );
+  }
+
+  void test_notContains_isTrue() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f(String s) {
+  expect(!s.contains(''), isTrue);
+}
+''',
+      [lint(84, 6, name: 'use_is_not_and_contains_matchers')],
+    );
+  }
+
+  void test_notContains_true() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f(String s) {
+  expect(!s.contains(''), true);
+}
+''',
+      [lint(84, 4, name: 'use_is_not_and_contains_matchers')],
+    );
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/test/rules/use_is_empty_matcher_test.dart b/pkgs/test_analyzer_plugin/test/rules/use_is_empty_matcher_test.dart
new file mode 100644
index 000000000..a7197dd6e
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/test/rules/use_is_empty_matcher_test.dart
@@ -0,0 +1,155 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// ignore_for_file: non_constant_identifier_names
+
+import 'package:analyzer/utilities/package_config_file_builder.dart';
+import 'package:analyzer_testing/analysis_rule/analysis_rule.dart';
+import 'package:test_analyzer_plugin/src/rules/use_is_empty_matcher.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(UseIsEmptyMatcherTest);
+  });
+}
+
+@reflectiveTest
+class UseIsEmptyMatcherTest extends AnalysisRuleTest {
+  @override
+  void setUp() {
+    rule = UseIsEmptyMatcherRule();
+    super.setUp();
+
+    var matcherPath = '/packages/matcher';
+    newFile('$matcherPath/lib/matcher.dart', '''
+void expect(dynamic actual, dynamic matcher) {}
+
+const isNotNull = 0;
+const isNull = 0;
+
+const isEmpty = 0;
+const isFalse = 0;
+const isNotEmpty = 0;
+const isTrue = 0;
+''');
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'matcher', rootPath: convertPath(matcherPath)),
+    );
+  }
+
+  void test_isEmpty_false() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.isEmpty, false);
+}
+''',
+      [lint(71, 5, name: 'use_is_not_empty_matcher')],
+    );
+  }
+
+  void test_isEmpty_isFalse() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.isEmpty, isFalse);
+}
+''',
+      [lint(71, 7, name: 'use_is_not_empty_matcher')],
+    );
+  }
+
+  void test_isEmpty_isTrue() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.isEmpty, isTrue);
+}
+''',
+      [
+        lint(71, 6, messageContainsAll: ['isEmpty']),
+      ],
+    );
+  }
+
+  void test_isEmpty_true() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.isEmpty, true);
+}
+''',
+      [
+        lint(71, 4, messageContainsAll: ['isEmpty']),
+      ],
+    );
+  }
+
+  void test_isEmptyMatcher() async {
+    await assertNoDiagnostics(r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect('', isEmpty);
+}
+''');
+  }
+
+  void test_isNotEmpty_false() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.isNotEmpty, false);
+}
+''',
+      [
+        lint(74, 5, messageContainsAll: ['isEmpty']),
+      ],
+    );
+  }
+
+  void test_isNotEmpty_isFalse() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.isNotEmpty, isFalse);
+}
+''',
+      [
+        lint(74, 7, messageContainsAll: ['isEmpty']),
+      ],
+    );
+  }
+
+  void test_isNotEmpty_isTrue() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.isNotEmpty, isTrue);
+}
+''',
+      [lint(74, 6, name: 'use_is_not_empty_matcher')],
+    );
+  }
+
+  void test_isNotEmpty_true() async {
+    await assertDiagnostics(
+      r'''
+import 'package:matcher/matcher.dart';
+void f() {
+  expect(''.isNotEmpty, true);
+}
+''',
+      [lint(74, 4, name: 'use_is_not_empty_matcher')],
+    );
+  }
+}
diff --git a/pkgs/test_analyzer_plugin/test/with_test_package.dart b/pkgs/test_analyzer_plugin/test/with_test_package.dart
new file mode 100644
index 000000000..c0001777c
--- /dev/null
+++ b/pkgs/test_analyzer_plugin/test/with_test_package.dart
@@ -0,0 +1,54 @@
+import 'package:analyzer/utilities/package_config_file_builder.dart';
+import 'package:analyzer_testing/analysis_rule/analysis_rule.dart';
+
+mixin WithTestPackage on AnalysisRuleTest {
+  @override
+  void setUp() {
+    super.setUp();
+
+    var testCorePath = '/packages/test_core';
+    newFile('$testCorePath/lib/test_core.dart', '''
+void group(
+  Object? description,
+  dynamic body(), {
+  String? testOn,
+  Object? /*Timeout?*/ timeout,
+  Object? skip,
+  Object? tags,
+  Map<String, dynamic>? onPlatform,
+  int? retry,
+  Object? /*TestLocation?*/ location,
+  bool solo = false,
+}) {}
+
+void test(
+  Object? description,
+  dynamic body(), {
+  String? testOn,
+  Object? /*Timeout?*/ timeout,
+  Object? skip,
+  Object? tags,
+  Map<String, dynamic>? onPlatform,
+  int? retry,
+  Object? /*TestLocation?*/ location,
+  bool solo = false,
+}) {}
+
+void setUp(dynamic callback()) {}
+
+void setUpAll(dynamic callback(), {
+  Object? /*TestLocation?*/ location,
+}) {}
+
+void tearDown(dynamic callback()) {}
+
+void tearDownAll(dynamic callback(), {
+  Object? /*TestLocation?*/ location,
+}) {}
+''');
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'test_core', rootPath: convertPath(testCorePath)),
+    );
+  }
+}