Reliable way to prove that int++ is not atomic

I can already see it's not by the incorrect increments, but there's just one small piece of the puzzle I can't quite seem to catch.

We have the following code:

internal class StupidObject
{
    static public SemaphoreSlim semaphore = new SemaphoreSlim(0, 100);

    private int counter;

    public bool MethodCall() => counter++ == 0;

    public int GetCounter() => counter;
}

And the following test code to try and see if it's an atomic operation:

var sharedObj = new StupidObject();
var resultTasks = new Task[100];
for (int i = 0; i < 100; i++)
{
    resultTasks[i] = Task.Run(async () =>
    {
        await StupidObject.semaphore.WaitAsync();
        if (sharedObj.MethodCall())
        {
            Console.WriteLine("True");
        };
    });
}
Console.WriteLine("Done");

Console.ReadLine();


StupidObject.semaphore.Release(100);

Console.ReadLine();

Console.WriteLine(sharedObj.GetCounter());

Console.ReadLine();

I expect to see multiple True's written to the console, but I ever see a single one.

Why is that? By my understanding, a ++ operation reads the value, increments the read value, and then stores that value to the variable.

Those are 3 operations. If we had a race condition, where thread A did the following:

• Reads value to be 0.
• Increments read value by 1.

And another thread B did the same things, but beat thread A to the third operation as following:

• Writes read value to variable.

When A finishes writing the incremented read value, it should print back 0, same with thread B after it has done its write operation.

Am I missing something at the design aspect of things, or is my test not good enough to make this exact situation come to fruition?

Example without the Task Parallel Library (still yields a single True to the console):

var sharedObj = new StupidObject();
var resultTasks = new Thread[10000];
for (int i = 0; i < 10000; i++)
{
    resultTasks[i] = new Thread(() =>
    {
        StupidObject.semaphore.Wait();
        if (sharedObj.MethodCall())
        {
            Console.WriteLine("True");
        };
    });
    resultTasks[i].IsBackground = false;
    resultTasks[i].Start();
}
Console.WriteLine("Done");

Console.ReadLine();


StupidObject.semaphore.Release(10000);