Can you change this to cpp17_input_iterator<operator_hijacker*> i at the same time? I think that's what was intended here: we just need a non-forward iterator whose value_type is operator_hijacker, and the rest doesn't matter. (Honestly I don't see why it needs to be a non-forward iterator — operator_hijacker *i might do just as well — but I dunno.)
@Mordante, who I believe wrote this code originally: does that sound right to you?

Given that range_t is hard-coded to array<int,10> on line 22, do you have the appetite to change this to a simple

int a[10] = {};

and then replace range.begin() with a throughout lines 54–65? Since you're rewriting this test (for the better) anyway...

FWIW, here I'd prefer to see

auto first = It(range.begin());  // or It(a) after the refactoring above
auto last = Sent(It(range.begin() + n));  // or Sent(It(a + n)) after the refactoring above

After the /range/a/ refactoring above, this becomes using It = int*; (unless the constness is important for some reason, and I don't think it is), at which point you don't really need the name It anymore.

(I note that all of these lines depend on CTAD, which is not thrilling. But that's a pre-existing issue. Just wanted to complain about it.)

I believe this change is wrong. IIUC your goal is to get some coverage for sentinels. I'm generally opposed to the current state of your rewrite only because it seems to hard-code the assumption that stride_counting_iterator<X> is necessarily a sentinel for stride_counting_iterator<Y>. I think it needs to use sentinel_wrapper instead. It should IMO look like

template <std::input_or_output_iterator It>
constexpr void check_assignable(It it, int *last) {
  {
    It result = std::ranges::next(std::move(it), It(last));
    assert(base(result) == last);
  }

  // Count operations
  {
    auto strided_it = stride_counting_iterator<It>(std::move(it));
    auto strided_last = sentinel_wrapper(stride_counting_iterator<It>(It(last)));  // CTAD alert!
    auto result = std::ranges::next(std::move(strided_it), std::move(strided_last));
    assert(result.stride_count() == 0); // because we got here by assigning from last, not by incrementing
    assert(base(result.base()) == last);  // .base() on the strided_iterator, ADL base() on the test iterator itself
  }
}

except what is this test talking about, "assigning from last"? In general sentinels (e.g. sentinel_wrapper) cannot be assigned to their iterator types, only compared against them. It sounds like this test file needs an ad-hoc struct assignable_sentinel and also a struct assignable_sized_sentinel, both of which should trigger https://eel.is/c++draft/iterators#range.iter.op.advance-4.1 .

(I'm totally OK with marking this TODO and coming back to it in a later PR, since the bulk of this PR is a huge improvement.)

Might be moot if you take my advice above: Could this just be if constexpr (std::is_copyable_v<It>), instead of introducing bool Count? Or what is the thing physically preventing this codepath from working for cpp17_input_iterator?

But this isn't a test for the default constructor — it's a test for the assignment operator. Input iterators must be assignable, right?
Perhaps change line 31 to std::move_iterator<It> move_ti(It(nullptr)); instead.

Any appetite to make this

template<class T>
struct ForwardView : std::ranges::view_base {
    forward_iterator<T*> begin() const;
    sentinel_wrapper<forward_iterator<T*>> end() const;
};

while you're here? Ditto below. (If that's a bridge too far, then OK, forget it.)

Here I believe we're losing test coverage of std::ranges::common_range<R> where R happens to be a common range with input iterators. However, this test is also bad (pre-existing issue). Maybe drop a TODO comment here? test_common_range should go away, and this test should look more like

template<class It> struct Common { It begin(); It end(); };
template<class It, class Sent> struct NonCommon { It begin(); Sent end(); };

static_assert(std::ranges::common_range<Common<cpp17_input_iterator<int*>>>);
static_assert(std::ranges::common_range<NonCommon<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>>);
static_assert(std::ranges::common_range<Common<cpp20_input_iterator<int*>>>);
static_assert(std::ranges::common_range<NonCommon<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>>);
static_assert(std::ranges::common_range<Common<forward_iterator<int*>>>);
static_assert(std::ranges::common_range<NonCommon<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>>);
~~~
static_assert(std::ranges::common_range<Common<int*>>);
static_assert(std::ranges::common_range<NonCommon<int*, const int*>>);
static_assert(std::ranges::common_range<NonCommon<int*, sentinel_wrapper<int*>>>);
static_assert(std::ranges::common_range<NonCommon<int*, sized_sentinel<int*>>>);

(notice that this includes the subtly_not_common case as well)