int AddOne(int input) { return input + 1; }

int main()
{
    int testVar = 0;
    
    //Name of test group is optional
    ssTEST_INIT_TEST_GROUP("ssTest Quick Start");
    
    ssTEST_COMMON_SETUP
    {
        testVar = 1;
    };
    
    ssTEST("testVar Should Be Initialized By Common Setup")
    {
        ssTEST_OUTPUT_ASSERT_TRUE(testVar == 1);
    };
    
    ssTEST("Setup And Execution Example")
    {
        //ssTEST_OUTPUT_SETUP is optional
        ssTEST_OUTPUT_SETUP
        (
            int testVar2 = 10;
        );
        
        //ssTEST_OUTPUT_EXECUTION is optional
        ssTEST_OUTPUT_EXECUTION
        (
            testVar = AddOne(testVar2);
        );
        
        ssTEST_OUTPUT_ASSERT_EQ(testVar, testVar2 + 1);
    };

    ssTEST_END_TEST_GROUP();
}

int main()
{
    int testVar = 0;
    int cleanUpCount = 0;
    
    ssTEST_INIT_TEST_GROUP();
    
    ssTEST_COMMON_SETUP{ testVar = 1;};
    ssTEST_COMMON_CLEANUP{ cleanUpCount++; };
    //ssTEST_DISABLE_COMMON_SETUP_CLEANUP_BETWEEN_TESTS();
    
    ssTEST("A Normal Test")
    {
        ssTEST_OUTPUT_ASSERT_EQ(testVar, 1);
        testVar = 5;
    };
    
    ssTEST("Another Normal Test")
    {
        ssTEST_OUTPUT_ASSERT_EQ(testVar, 1);
        ssTEST_OUTPUT_ASSERT_EQ(cleanUpCount, 1);
        
        //If ssTEST_DISABLE_COMMON_SETUP_CLEANUP_BETWEEN_TESTS() is called, 
        //  testVar would be 5 and cleanUpCount would be 0
    };

    ssTEST_END_TEST_GROUP();
}

int main()
{
    ssTEST_INIT_TEST_GROUP();
    
    ssTEST("A Normal Test")
    {
        ssTEST_OUTPUT_ASSERT_TRUE(true);
    };
    
    ssTEST_ONLY_THIS("Will Only Run This Test")
    {
        ssTEST_OUTPUT_ASSERT_TRUE(true);
    };
    
    ssTEST_SKIP("Will Skip This Test")
    {
        ssTEST_OUTPUT_ASSERT_TRUE(true);
    };
    
    ssTEST_END_TEST_GROUP();
}

int main()
{
    MyMemoryAllocator testAllocator;
    
    ssTEST_INIT_TEST_GROUP();

    ssTEST_COMMON_SETUP
    {
        testAllocator = MyMemoryAllocator_Create(64, 12);
    };

    ssTEST_COMMON_CLEANUP
    {
        MyMemoryAllocator_Destroy(&testAllocator);
    };

    ssTEST("MyMemoryAllocator_Create Should Not Crash When Requesting Zero Memory")
    {
        //We want to create our own memory allocator and request empty memory
        ssTEST_CALL_COMMON_CLEANUP();
        
        ssTEST_OUTPUT_EXECUTION
        (
            testAllocator = MyMemoryAllocator_Create(64, 0);
        );
        
        ssTEST_OUTPUT_ASSERT_EQ(testAllocator.PageSize, 64);
        ssTEST_OUTPUT_ASSERT_EQ(testAllocator.PageCount, 0);
    };
    
    ssTEST("MyMemoryAllocator_CreateShared Should Create Shared Memory Allocator")
    {
        ssTEST_OUTPUT_SETUP
        (
            const int pageSize = 64;
            const int pageCount = 4;
            MyMemoryAllocator sharedAllocator;
            void* sharedMemory = MyMemoryAllocator_Allocate(&testAllocator, 
                                                            pageSize * pageCount + 
                                                            pageCount * sizeof(short));
        );
        
        ssTEST_OUTPUT_EXECUTION
        (
            sharedAllocator = MyMemoryAllocator_CreateShared(sharedMemory, pageSize, pageCount);
        );
        
        ssTEST_OUTPUT_ASSERT_EQ(sharedAllocator.AllocateID_Table, (short*)sharedMemory);
        ssTEST_OUTPUT_ASSERT_EQ(sharedAllocator.Memory, (char*)sharedMemory + pageCount * sizeof(short));
        ssTEST_OUTPUT_ASSERT_EQ(sharedAllocator.PageSize, pageSize);
        ssTEST_OUTPUT_ASSERT_EQ(sharedAllocator.PageCount, pageCount);
        
        MyMemoryAllocator_Destroy(&sharedAllocator);
    };

    ssTEST("MyMemoryAllocator_Allocate Should Allocate Memory When Enough Memory Is Available")
    {
        ssTEST_OUTPUT_SETUP
        (
            const int pageSize = 64;
            char* memory;
            int pageCount = 4;
        );
        
        for(int i = 0; i < 2; i++)
        {
            ssTEST_OUTPUT_EXECUTION
            (
                memory = (char*)MyMemoryAllocator_Allocate(&testAllocator, pageSize * pageCount);
            );
        }
        
        ssTEST_OUTPUT_EXECUTION
        (
            *memory = 17;
            *(memory + pageSize * pageCount - 1) = 17;
        );
        
        //This also works without a message as well
        ssTEST_OUTPUT_ASSERT_NOT_EQ(memory, nullptr, "Memory Result");
        
        //Asserting by passing two values (to compare equality) will also print the values
        ssTEST_OUTPUT_ASSERT_EQ(*memory, 17, "Reading to beginning of memory");
        
        //You can also specify the operator to use for comparison
        ssTEST_OUTPUT_ASSERT_EQ(*(memory + pageSize * pageCount - 1), 17, "Reading to end of memory");
    };
    
    ssTEST("MyMemoryAllocator_Allocate Should Return NULL When Not Enough Memory Is Available")
    {
        ssTEST_OUTPUT_SETUP
        (
            const int pageSize = 64;
        );
        
        //Let's say this is not implemented or we know it is crashing, we can skip the assert 
        //or even skip the whole test with ssTEST_SKIP
        ssTEST_MARK_SKIP_ASSERT_START();
        
        ssTEST_OUTPUT_ASSERT_EQ((char*)MyMemoryAllocator_Allocate(&testAllocator, pageSize * 250),
                               nullptr,
                               "Allocation Result");
        
        ssTEST_MARK_SKIP_ASSERT_END();
    };
    
    ssTEST("MyMemoryAllocator_Allocate Should Return NULL When Zero Size Is Passed In")
    {
        ssTEST_OUTPUT_SETUP
        (
            char* memory;
        );
        (void)memory;
        
        ssTEST_OUTPUT_EXECUTION
        (
            memory = (char*)MyMemoryAllocator_Allocate(&testAllocator, 0);
        );
        
        //Let's say there's a bug in the allocator which will probably fail the assert, 
        //but we still want to know the result. An optional assert can be used in this case.
        ssTEST_MARK_OPTIONAL_ASSERT_START();
        
        ssTEST_OUTPUT_ASSERT_EQ(memory, nullptr, "Allocation Result");
        
        ssTEST_MARK_OPTIONAL_ASSERT_END();
    };

    //etc...

    ssTEST_END_TEST_GROUP();
}

int main(int argc, char* argv[])
{
    ssTEST_INIT_TEST_GROUP();
    ssTEST_PARSE_ARGS(argc, argv);
    
    ssTEST("My Test")
    {
        //...
    };
    
    ssTEST_END_TEST_GROUP();
}