Yhyjyk

This works on a shell (bash, dash) prompt:

[ -z "" ] && echo A || echo B
A

However, I am trying to write a POSIX shell script, it starts like this:

#!/bin/sh

[ "$#" -eq 1 ] || echo "Invalid number of arguments, expected one."; exit 1

readonly raw_input_string=$1

[ -z "$raw_input_string" ] && echo "The given argument is empty."; exit 1

And I don't know why, but I don't get the message:

The given argument is empty.

if I call the script like this:

./test_empty_argument ""

Why is that?

Note that your line

[ "$#" -eq 1 ] || echo "Invalid number of arguments, expected one."; exit 1

this is the same as

[ "$#" -eq 1 ] || echo "Invalid number of arguments, expected one."
exit 1

(a ; can, in most circumstances, be replaced by a newline character)

Which means that the exit 1 statement is always executed regardless of how many arguments were passed to the script. This means that the message The given argument is empty. would never have a chance of getting printed.

To execute more than a single statement after a test using the "short-circuit syntax", group the statements in ...; . The alternative is to use a proper if test (which, IMHO, looks cleaner in a script):

if [ "$#" -ne 1 ]; then
 echo 'Invalid number of arguments, expected one.' >&2
 exit 1
fi

You have the same issue with your second test.

Regarding

[ -z "" ] && echo A || echo B

This would work for the given example, but the generic

some-test && command1 || command2

would not be the same as

if some-test; then
 command1
else
 command2
fi

Instead, it is more like

if ! some-test && command1; ; then
 command2
fi

That is, if either the test or the first command fails, the second command executes, which means it has the potential to execute all three involved statements.

This:

[ "$#" -eq 1 ] || echo "Invalid number of arguments, expected one."; exit 1

is not:

[ "$#" -eq 1 ] || echo "Invalid number of arguments, expected one."; exit 1; 

But instead is:

 [ "$#" -eq 1 ] 
exit 1

Your script is exiting regardless of how many arguments you passed to it.

One way to make it more readable is to define a die function (à la perl) like:

die() 
 printf >&2 '%sn' "$@"
 exit 1


# then:

[ "$#" -eq 1 ] || die "Expected one argument, got $#"

[ -n "$1" ] || die "Empty argument not supported"

You can add more bells and whistles like colours, prefix... if need be.

I've often seen this as a test for an empty string:

if [ "x$foo" = "x" ]; then ...

I would also add to the other answers that a POSIX shell may detect variable assignment errors.

#!/bin/sh -u

foo=$1:? # choose a meaninful variable name and possibly use an error message.
 # ... if the first parameter is unset or empty the shell exits.
bar=$2- # if the second parameter is set, then the shell assigns its value, else
 # it assigns the empty string.

# displays the date if "var" is empty, else, prints the working directory.
[ -z "$var-" ] && date || pwd

# "var" is set to the empty string. I assume the nineth parameter is not set.
# `echo "$9"' returns 1 so the shell also runs `echo "var not empty: $var"'
[ -z "$var-" ] && echo "$9" || echo "var not empty: $var"

# `echo "var empty"' returns 0
[ -z "$var-" ] && echo "var empty" || echo "var not empty: $var"

var=0101

[ -z "$var-" ] && echo "var empty" || echo "var not empty: $var"

The shell exits if any variable is unset while the shell option -u is enabled. The shell expansions used in the sample script are also defined by POSIX.