Count sort implementation
Limitations

Being able to sort in \$O(n)\$, counting sort can be very efficient,
but with the right kind of data.
Just keep in mind that it won't work well when the variation in values is very large.

Optimizations and extensions

The implementation checks the maximum value,
so the array of counts will use that much space.
You could reduce the amount of space used by finding the minimum too.
That way the size of the array of counts could be max - min instead of max.
That will of course require to use the min as an offset both when building the array of counts,
and when writing the output.

Related to that, the current implementation doesn't support negative values in the input.
But it could, by using the minimum value as an offset.
In fact,
by applying the optimization above,
negative numbers will be automatically supported.

Unnecessary storage and mutations

There's no need for the temporary output array,
and for modifying the content of count to contain positions.
Once you have the array of counts,
you can directly overwrite the target array,
reducing the amount of code and simplifying the implementation.

for (int countIndex = 0, outIndex = 0; countIndex &lt; count.Length; ++countIndex)
{
    for (int i = 0; i &lt; count[countIndex]; ++i)
    {
        arr[outIndex++] = countIndex;
    }
}


Unnecessary array initialization

int[] arrays are initialized with zeros,
no need to manually set the content to zeros.

Style tips

It's recommended to always use braces with loops and conditionals.

Testing

It's better to use a proper unit testing framework that gives you simple pass-or-fail results,
rather than reading the output and verifying manually that it's actually correct.