正则只检查中间一段，为什么锚点和前后文仍会改变结果？

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    private static int checks;

    private static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
        checks++;
    }

    private static void rejects(Class<? extends Throwable> expected, Runnable action) {
        try {
            action.run();
        } catch (Throwable error) {
            check(expected.isInstance(error), "unexpected exception: " + error);
            return;
        }
        throw new AssertionError("expected " + expected.getSimpleName());
    }

    private static Matcher middle(String pattern, boolean anchoring, boolean transparent) {
        return Pattern.compile(pattern).matcher("XabcY").region(1, 4)
                .useAnchoringBounds(anchoring).useTransparentBounds(transparent);
    }

    public static void main(String[] args) {
        Matcher defaults = Pattern.compile("^abc$").matcher("XabcY").region(1, 4);
        check(defaults.hasAnchoringBounds(), "default anchoring");
        check(!defaults.hasTransparentBounds(), "default opaque bounds");
        check(defaults.matches(), "anchors at region edges");
        check(defaults.start() == 1 && defaults.end() == 4 && defaults.group().equals("abc"),
                "indices remain relative to the complete input");
        System.out.println("default: input=XabcY region=[1,4) group=abc span=[1,4)");

        for (boolean anchoring : new boolean[]{false, true}) {
            for (boolean transparent : new boolean[]{false, true}) {
                boolean anchors = middle("^abc$", anchoring, transparent).matches();
                boolean context = middle("(?<=X)abc(?=Y)", anchoring, transparent).matches();
                check(anchors == anchoring, "anchoring matrix");
                check(context == transparent, "lookaround matrix");
                check(middle("abc", anchoring, transparent).matches(), "plain region match");
                check(!middle("XabcY", anchoring, transparent).matches(),
                        "transparent lookaround does not consume outside the region");
                System.out.println("bounds anchoring=" + anchoring + " transparent=" + transparent
                        + ": anchors=" + anchors + " lookaround=" + context);
            }
        }
        check(Pattern.compile("^abc$").matcher("abc").useAnchoringBounds(false).matches(),
                "real input edges still work without regional anchors");

        Pattern literal = Pattern.compile("abc");
        String larger = "xxabcYY";
        boolean all = literal.matcher(larger).region(2, 7).matches();
        boolean prefix = literal.matcher(larger).region(2, 7).lookingAt();
        boolean found = literal.matcher(larger).region(2, 7).find();
        check(!all && prefix && found, "whole region versus its prefix or a subsequence");
        check(!literal.matcher(larger).region(1, 7).lookingAt(), "prefix starts at region start");
        check(literal.matcher(larger).region(1, 7).find(), "find may scan within region");
        System.out.println("region=abcYY: matches=" + all + " lookingAt=" + prefix + " find=" + found);

        String text = "12abc34def56";
        Matcher state = Pattern.compile("[a-z]+").matcher(text).region(2, 5)
                .useAnchoringBounds(false).useTransparentBounds(true);
        check(state.find() && state.group().equals("abc"), "first regional match");
        state.reset();
        check(state.regionStart() == 0 && state.regionEnd() == text.length(), "reset restores full region");
        check(!state.hasAnchoringBounds() && state.hasTransparentBounds(), "reset keeps bound flags");
        rejects(IllegalStateException.class, () -> state.group());
        System.out.println("reset: region=[0,12) anchoring=false transparent=true group=undefined");

        state.region(2, 5);
        check(state.find() && state.group().equals("abc"), "narrow again");
        check(state.find(7) && state.group().equals("def"), "find(start) resets before searching");
        check(state.regionStart() == 0 && state.regionEnd() == 12
                && state.start() == 7 && state.end() == 10, "find(start) uses full-input indices");
        System.out.println("find(7): region=[0,12) group=def span=[7,10)");

        state.region(7, 10);
        rejects(IllegalStateException.class, () -> state.start());
        check(state.matches() && state.group().equals("def"), "region resets previous match state");
        check(!state.hasAnchoringBounds() && state.hasTransparentBounds(), "region keeps bound flags");

        Matcher empty = Pattern.compile("^$").matcher("abc").region(2, 2);
        check(empty.matches() && empty.start() == 2 && empty.end() == 2, "empty region is legal");
        rejects(IndexOutOfBoundsException.class, () -> Pattern.compile(".").matcher("abc").region(-1, 2));
        rejects(IndexOutOfBoundsException.class, () -> Pattern.compile(".").matcher("abc").region(0, 4));
        rejects(IndexOutOfBoundsException.class, () -> Pattern.compile(".").matcher("abc").region(2, 1));
        rejects(IndexOutOfBoundsException.class, () -> state.find(13));
        System.out.println("empty-region=matched; invalid-regions=3 rejected; invalid-find-start=1 rejected");
        System.out.println("PASS " + checks + " checks; fixed ASCII input, no regex performance claim");
    }
}