Call‑by‑name will succeeds where call‑by‑value may fails: some example cases?
Call-by-value evaluates the arguments to a function exactly once.  Call-by-name evaluates the arguments to a function, zero, once, or more times.  Call-by-need evaluates the arguments to a function zero or once, but not more than once.

The trick you are looking for here is a case where call-by-value needs to evaluate an argument once while call-by-name does not need to evaluate its argument at all.  The particular thing that Church and Rosser were worried about was that the argument might be an infinite loop.

So if I have the following

fun call_by_name (cond a b) =
  if cond
    a
  else
    b


and

fun loop_forever () =
   loop_forever()


Then

call_by_name(true, 1, loop_forever())


will return 1 while

call_by_value(true, 1, loop_forever())


will loop forever.

Actually, call-by-name is super cool because it allows you to implement control-flow constructs like if-then-else and while-do.  Suppose, for example that your language doesn't have if-then-else built in.  You can implement boolean values True and false and if-then-else in call-by-name as follows:

fun True  (t f) = t
fun False (t f) = f
fun if_else (cond t f) = cond(t f)


Now

if_else(True, 1, loop_forever())


returns 1 and

if_else(False, loop_forever(), 0)


returns 0.