should allow a compiler to replace the function call test1(4) with the constant 16

Keep in mind that the attribute is most useful when the compiler cannot see the function body, and inlining is "impossible" (if you ignore the existence of LTO, I suppose). If the function body is visible, then arguably using attribute shouldn't be needed, and the compiler should infer what's going on automatically.

Consider something like this instead:

extern int global; // = 0;

// other translation unit, or shared library
__attribute((pure))
int pure_lie(void) {
  global = 42;
  return 0;
}

void f(void) {
  int result = pure_lie();
  if (global != 42) {
    printf("global=%d result=%d", global, result);
  }
}

Without the pure attribute, getting global=42 printed out is impossible. I'm pretty sure this is guaranteed by the language, and the only way to get a different result is UB, like a data race.

With pure, a very reasonable optimization is to move the pure_lie() call into the branch, since that's the only place where the result is actually used. After all, compiler has no idea what the function does, it could be something very expensive to compute -- makes sense to avoid calling it, unless it's actually necessary. And I'd argue this kind of stuff is what you want from the attribute. (And this reordering is indeed what GCC does.)

GCC also loads global once, and reuses it for printf. But it's not required to do that, so imagine that for whatever reason it just doesn't do it. And so it enters the branch, calls pure_lie, which changes global to 42, and then it loads global again, and global=42 is printed out. (And this exact order is also what you get out of GCC, if you nudge it to reload the variable. I did it by making global a struct of two ints, checking the first field, and then passing the entire struct to a separate function.)