Souce Pawn: New String Stocks - Test

#include <sourcemod>

#pragma semicolon 1
#pragma newdecls required

public Plugin myinfo =  {
    name = "String Functions Test",
    author = "milutinke",
    description = "String Functions Test",
    version = "1.0.0",
    url = ""
};

public void OnPluginStart() {
    PrintToServer("=====================================================");
    Test("IsStringNumber", "1", _, true, _);
    Test("IsStringNumber", "a", _, true, _);
    Test("IsStringNumber", "1234b211211", _, true, _);
    Test("IsStringNumber", "23232a", _, true, _);
    Test("IsStringNumber", "-7153512719111222352", _, true, _);
    Test("IsStringNumber", "-3", _, true, _);
    Test("IsStringNumber", "3.14", _, true, _);
    Test("IsStringNumber", "som3wo4d", _, true, _);
    PrintToServer("=====================================================");
    Test("IsStringFloat", "1", _, true, _);
    Test("IsStringFloat", "a", _, true, _);
    Test("IsStringFloat", "134335.2345673", _, true, _);
    Test("IsStringFloat", "23232a", _, true, _);
    Test("IsStringFloat", "-7153512719111222352.6", _, true, _);
    Test("IsStringFloat", "-3", _, true, _);
    Test("IsStringFloat", "3.14", _, true, _);
    Test("IsStringFloat", "s.om.3wo4.d", _, true, _);
    Test("IsStringFloat", "0.5", _, true, _);
    PrintToServer("=====================================================");
    Test("IndexOfChar", "abcdefabcdef", 'f', 5, _);
    Test("IndexOfChar", "abcdefabcdef", 'f', 11, _);
    Test("IndexOfChar", "abcdefghijklmnopqurstuvxyz", 'z', 25, _);
    Test("IndexOfChar", "abcdefgahijaklmnopaqurstauvxyza", 'a', 0, _);
    PrintToServer("=====================================================");
    Test("LastIndexOfChar", "abcdefabcdef", 'f', 11, _);
    Test("LastIndexOfChar", "abcdefabcdef", 'f', 5, _);
    Test("LastIndexOfChar", "azbcdefgzhijklmnopqurstuvxyz", 'z', 27, _);
    Test("LastIndexOfChar", "abcdefgahijaklmnopaqurstauvxyza", 'a', 30, _);
    PrintToServer("=====================================================");
    Test("StringToLowerCase", "AbbAAAAAbAAAAAAbbbbAAA", _, _, "abbaaaaabaaaaaabbbbaaa");
    PrintToServer("=====================================================");
    Test("StringToUpperCase", "aBBaaaaaBaaaaaaBBBBaaa", _, _, "ABBAAAAABAAAAAABBBBAAA");
    PrintToServer("=====================================================");
}

public void OnPluginEnd() {

}

stock void Test(const char[] szTestName, char[] szInput, char cInput = 'a', const any aExpectedValue = 0, const char[] szExpectedValue = "") {
    if(StrEqual(szTestName, "IsStringNumber")) {
        PrintToServer("Test %s > Input value: %s - %s", szTestName, szInput, IsStringNumber(szInput) == aExpectedValue ? "PASSED" : "FAILED");
    }

    if(StrEqual(szTestName, "IsStringFloat")) {
        PrintToServer("Test %s > Input value: %s - %s", szTestName, szInput, IsStringFloat(szInput) == aExpectedValue ? "PASSED" : "FAILED");
    }

    if(StrEqual(szTestName, "IndexOfChar")) {
        PrintToServer("Test %s > Input value: %s - %c (Input Position: %d) - %s", szTestName, szInput, cInput, aExpectedValue, IndexOfChar(szInput, cInput) == aExpectedValue ? "PASSED" : "FAILED");
    }

    if(StrEqual(szTestName, "LastIndexOfChar")) {
        PrintToServer("Test %s > Input value: %s - %c (Input Position: %d) - %s", szTestName, szInput, cInput, aExpectedValue, LastIndexOfChar(szInput, cInput) == aExpectedValue ? "PASSED" : "FAILED");
    }

    if(StrEqual(szTestName, "StringToLowerCase")) {
        char[] szTemporary = new char[strlen(szInput) + 1];
        strcopy(szTemporary, strlen(szInput) + 1, szInput);
        StringToLowerCase(szTemporary);
        PrintToServer("Test %s > Input value: %s - Output Value: %s - %s", szTestName, szInput, szTemporary, StrEqual(szTemporary, szExpectedValue) ? "PASSED" : "FAILED");
    }

    if(StrEqual(szTestName, "StringToUpperCase")) {
        char[] szTemporary = new char[strlen(szInput) + 1];
        strcopy(szTemporary, strlen(szInput) + 1, szInput);
        StringToUpperCase(szTemporary);
        PrintToServer("Test %s > Input value: %s - Output Value: %s - %s", szTestName, szInput, szTemporary, StrEqual(szTemporary, szExpectedValue) ? "PASSED" : "FAILED");
    }
}

/**
 * Checks if the given string is an integer (Supports negative values)
 *
 * @param szString     Input string
 * @return             Boolean
 */
stock bool IsStringNumber(const char[] szString) {
    int iIterator = 0;
    int iLength = strlen(szString);

    char[] szTemporary = new char[iLength + 1];
    strcopy(szTemporary, iLength + 1, szString);

    TrimString(szTemporary);

    if (szTemporary[0] == '-' && iLength > 1)
        ++iIterator;

    while (szTemporary[iIterator] && IsCharNumeric(szTemporary[iIterator]))
        ++iIterator;

    return szTemporary[iIterator] == 0 && iIterator != 0;
}

/**
 * Converts the given string to lower case
 *
 * @param szString     Input string for conversion and also the output
 * @return             void
 */
stock void StringToLowerCase(char[] szInput) {
    int iIterator = 0;
    int iLength = strlen(szInput);
    char[] szOutput = new char[iLength + 1];

    while (szInput[iIterator] != EOS) {
        if (!IsCharLower(szInput[iIterator]))szOutput[iIterator] = CharToLower(szInput[iIterator]);
        else szOutput[iIterator] = szInput[iIterator];

        iIterator++;
    }

    szOutput[iIterator + 1] = EOS;
    strcopy(szInput, iLength + 1, szOutput);
}

/**
 * Converts the given string to upper case
 *
 * @param szString     Input string for conversion and also the output
 * @return             void
 */
stock void StringToUpperCase(char[] szInput) {
    int iIterator = 0;
    int iLength = strlen(szInput);
    char[] szOutput = new char[iLength + 1];

    while (szInput[iIterator] != EOS) {
        if (!IsCharUpper(szInput[iIterator]))szOutput[iIterator] = CharToUpper(szInput[iIterator]);
        else szOutput[iIterator] = szInput[iIterator];

        iIterator++;
    }

    szOutput[iIterator + 1] = EOS;
    strcopy(szInput, iLength + 1, szOutput);
}

/**
 * Checks if the given string is a float (Supports negative values)
 *
 * @param szString     Input string
 * @return             Boolean
 */
stock bool IsStringFloat(const char[] szString) {
    char cCharacter;
    int iIterator;
    int iP;
    int iLength = strlen(szString);

    while (0 < szString[iIterator] <= 255) {
        if (szString[0] == '-' && iLength > 1) {
            iIterator++;
            continue;
        }

        cCharacter = szString[iIterator];

        if (!IsCharNumeric(cCharacter)) {
            if (cCharacter != '.' || iP)
                return false;

            iP = 1;
        }

        iIterator++;
    }

    return (iIterator > 2);
}

/**
 * Finds the position (index) of character in the given string
 *
 * @param szString     Input string
 * @param szString     Input character
 * @param szString     Do we need the last index (Optional, default: false)
 * @return             Integer, index of the found character (returns -1 if the character was not found)
 */
stock int IndexOfChar(const char[] szText, const char cCharacter, bool bLast = false) {
    int iTextLength = strlen(szText);
    int iCharacter, iLastIndex = -1;

    for (iCharacter = 0; iCharacter < iTextLength; iCharacter++) {
        if (szText[iCharacter] == cCharacter) {
            iLastIndex = iCharacter;

            if (!bLast)
                break;
        }
    }

    return iLastIndex;
}

/**
 * Finds the last position (index) of character in the given string
 *
 * @param szString     Input string
 * @param szString     Input character
 * @return             Integer, index of the found character. (returns -1 if the character was not found)
 */
stock int LastIndexOfChar(const char[] szText, const char cCharacter) {
    return IndexOfChar(szText, cCharacter, true);
}