/**

 * Test program for PhysicsFS. May only work on Unix.

 *

 * Please see the file LICENSE in the source's root directory.

 *

 *  This file written by Ryan C. Gordon.

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#if (defined __MWERKS__)

#include <SIOUX.h>

#endif

#if (defined PHYSFS_HAVE_READLINE)

#include <unistd.h>

#include <readline/readline.h>

#include <readline/history.h>

#endif

#include <time.h>

#include "physfs.h"

#define TEST_VERSION_MAJOR  0

#define TEST_VERSION_MINOR  1

#define TEST_VERSION_PATCH  9

static FILE *history_file = NULL;

static PHYSFS_uint32 do_buffer_size = 0;

static void output_versions(void)

{

    PHYSFS_Version compiled;

    PHYSFS_Version linked;

    PHYSFS_VERSION(&compiled);

    PHYSFS_getLinkedVersion(&linked);

    printf("test_physfs version %d.%d.%d.\n"

           " Compiled against PhysicsFS version %d.%d.%d,\n"

           " and linked against %d.%d.%d.\n\n",

            TEST_VERSION_MAJOR, TEST_VERSION_MINOR, TEST_VERSION_PATCH,

            (int) compiled.major, (int) compiled.minor, (int) compiled.patch,

            (int) linked.major, (int) linked.minor, (int) linked.patch);

} /* output_versions */

static void output_archivers(void)

{

    const PHYSFS_ArchiveInfo **rc = PHYSFS_supportedArchiveTypes();

    const PHYSFS_ArchiveInfo **i;

    printf("Supported archive types:\n");

    if (*rc == NULL)

        printf(" * Apparently, NONE!\n");

    else

    {

        for (i = rc; *i != NULL; i++)

        {

            printf(" * %s: %s\n    Written by %s.\n    %s\n",

                    (*i)->extension, (*i)->description,

                    (*i)->author, (*i)->url);

        } /* for */

    } /* else */

    printf("\n");

} /* output_archivers */

static int cmd_quit(char *args)

{

    return(0);

} /* cmd_quit */

static int cmd_init(char *args)

{

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    if (PHYSFS_init(args))

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return(1);

} /* cmd_init */

static int cmd_deinit(char *args)

{

    if (PHYSFS_deinit())

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return(1);

} /* cmd_deinit */

static int cmd_addarchive(char *args)

{

    char *ptr = strrchr(args, ' ');

    int appending = atoi(ptr + 1);

    *ptr = '\0';

    if (*args == '\"')

    {

        args++;

        *(ptr - 1) = '\0';

    } /* if */

    /*printf("[%s], [%d]\n", args, appending);*/

    if (PHYSFS_addToSearchPath(args, appending))

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return(1);

} /* cmd_addarchive */

static int cmd_removearchive(char *args)

{

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    if (PHYSFS_removeFromSearchPath(args))

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return(1);

} /* cmd_removearchive */

static int cmd_enumerate(char *args)

{

    char **rc;

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    rc = PHYSFS_enumerateFiles(args);

    if (rc == NULL)

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    else

    {

        int file_count;

        char **i;

        for (i = rc, file_count = 0; *i != NULL; i++, file_count++)

            printf("%s\n", *i);

        printf("\n total (%d) files.\n", file_count);

        PHYSFS_freeList(rc);

    } /* else */

    return(1);

} /* cmd_enumerate */

static int cmd_getdirsep(char *args)

{

    printf("Directory separator is [%s].\n", PHYSFS_getDirSeparator());

    return(1);

} /* cmd_getdirsep */

static int cmd_getlasterror(char *args)

{

    printf("last error is [%s].\n", PHYSFS_getLastError());

    return(1);

} /* cmd_getlasterror */

static int cmd_getcdromdirs(char *args)

{

    char **rc = PHYSFS_getCdRomDirs();

    if (rc == NULL)

        printf("Failure. Reason: [%s].\n", PHYSFS_getLastError());

    else

    {

        int dir_count;

        char **i;

        for (i = rc, dir_count = 0; *i != NULL; i++, dir_count++)

            printf("%s\n", *i);

        printf("\n total (%d) drives.\n", dir_count);

        PHYSFS_freeList(rc);

    } /* else */

    return(1);

} /* cmd_getcdromdirs */

static int cmd_getsearchpath(char *args)

{

    char **rc = PHYSFS_getSearchPath();

    if (rc == NULL)

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    else

    {

        int dir_count;

        char **i;

        for (i = rc, dir_count = 0; *i != NULL; i++, dir_count++)

            printf("%s\n", *i);

        printf("\n total (%d) directories.\n", dir_count);

        PHYSFS_freeList(rc);

    } /* else */

    return(1);

} /* cmd_getcdromdirs */

static int cmd_getbasedir(char *args)

{

    printf("Base dir is [%s].\n", PHYSFS_getBaseDir());

    return(1);

} /* cmd_getbasedir */

static int cmd_getuserdir(char *args)

{

    printf("User dir is [%s].\n", PHYSFS_getUserDir());

    return(1);

} /* cmd_getuserdir */

static int cmd_getwritedir(char *args)

{

    printf("Write dir is [%s].\n", PHYSFS_getWriteDir());

    return(1);

} /* cmd_getwritedir */

static int cmd_setwritedir(char *args)

{

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    if (PHYSFS_setWriteDir(args))

        printf("Successful.\n");

    else

        printf("Failure. reason: %s.\n", PHYSFS_getLastError());

    return(1);

} /* cmd_setwritedir */

static int cmd_permitsyms(char *args)

{

    int num;

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    num = atoi(args);

    PHYSFS_permitSymbolicLinks(num);

    printf("Symlinks are now %s.\n", num ? "permitted" : "forbidden");

    return(1);

} /* cmd_permitsyms */

static int cmd_setbuffer(char *args)

{

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    do_buffer_size = (unsigned int) atoi(args);

    if (do_buffer_size)

    {

        printf("Further tests will set a (%lu) size buffer.\n",

                (unsigned long) do_buffer_size);

    } /* if */

    else

    {

        printf("Further tests will NOT use a buffer.\n");

    } /* else */

    return(1);

} /* cmd_setbuffer */

static int cmd_stressbuffer(char *args)

{

    int num;

    if (*args == '\"')

    {

        args++;

        args[strlen(args) - 1] = '\0';

    } /* if */

    num = atoi(args);

    if (num < 0)

        printf("buffer must be greater than or equal to zero.\n");

    else

    {

        PHYSFS_file *f;

        int rndnum;

        printf("Stress testing with (%d) byte buffer...\n", num);

        f = PHYSFS_openWrite("test.txt");

        if (f == NULL)

            printf("Couldn't open test.txt for writing: %s.\n", PHYSFS_getLastError());

        else

        {

            int i, j;

            char buf[37];

            char buf2[37];

            if (!PHYSFS_setBuffer(f, num))

            {

                printf("PHYSFS_setBuffer() failed: %s.\n", PHYSFS_getLastError());

                PHYSFS_close(f);

                PHYSFS_delete("test.txt");

                return(1);

            } /* if */

            strcpy(buf, "abcdefghijklmnopqrstuvwxyz0123456789");

            srand((unsigned int) time(NULL));

            for (i = 0; i < 10; i++)

            {

                for (j = 0; j < 10000; j++)

                {

                    PHYSFS_uint32 right = 1 + (PHYSFS_uint32) (35.0 * rand() / (RAND_MAX + 1.0));

                    PHYSFS_uint32 left = 36 - right;

                    if (PHYSFS_write(f, buf, left, 1) != 1)

                    {

                        printf("PHYSFS_write() failed: %s.\n", PHYSFS_getLastError());

                        PHYSFS_close(f);

                        return(1);

                    } /* if */

                    rndnum = 1 + (int) (1000.0 * rand() / (RAND_MAX + 1.0));

                    if (rndnum == 42)

                    {

                        if (!PHYSFS_flush(f))

                        {

                            printf("PHYSFS_flush() failed: %s.\n", PHYSFS_getLastError());

                            PHYSFS_close(f);

                            return(1);

                        } /* if */

                    } /* if */

                    if (PHYSFS_write(f, buf + left, 1, right) != right)

                    {

                        printf("PHYSFS_write() failed: %s.\n", PHYSFS_getLastError());

                        PHYSFS_close(f);

                        return(1);

                    } /* if */

                    rndnum = 1 + (int) (1000.0 * rand() / (RAND_MAX + 1.0));

                    if (rndnum == 42)

                    {

                        if (!PHYSFS_flush(f))

                        {

                            printf("PHYSFS_flush() failed: %s.\n", PHYSFS_getLastError());

                            PHYSFS_close(f);

                            return(1);

                        } /* if */

                    } /* if */

                } /* for */

                if (!PHYSFS_flush(f))

                {

                    printf("PHYSFS_flush() failed: %s.\n", PHYSFS_getLastError());

                    PHYSFS_close(f);

                    return(1);

                } /* if */

            } /* for */

            if (!PHYSFS_close(f))

            {

                printf("PHYSFS_close() failed: %s.\n", PHYSFS_getLastError());

                return(1);  /* oh well. */

            } /* if */

            printf(" ... test file written ...\n");

            f = PHYSFS_openRead("test.txt");

            if (f == NULL)

            {

                printf("Failed to reopen stress file for reading: %s.\n", PHYSFS_getLastError());

                return(1);

            } /* if */

            if (!PHYSFS_setBuffer(f, num))

            {

                printf("PHYSFS_setBuffer() failed: %s.\n", PHYSFS_getLastError());

                PHYSFS_close(f);

                return(1);

            } /* if */

            for (i = 0; i < 10; i++)

            {

                for (j = 0; j < 10000; j++)

                {

                    PHYSFS_uint32 right = 1 + (PHYSFS_uint32) (35.0 * rand() / (RAND_MAX + 1.0));

                    PHYSFS_uint32 left = 36 - right;

                    if (PHYSFS_read(f, buf2, left, 1) != 1)

                    {

                        printf("PHYSFS_read() failed: %s.\n", PHYSFS_getLastError());

                        PHYSFS_close(f);

                        return(1);

                    } /* if */

                    rndnum = 1 + (int) (1000.0 * rand() / (RAND_MAX + 1.0));

                    if (rndnum == 42)

                    {

                        if (!PHYSFS_flush(f))

                        {

                            printf("PHYSFS_flush() failed: %s.\n", PHYSFS_getLastError());

                            PHYSFS_close(f);

                            return(1);

                        } /* if */

                    } /* if */

                    if (PHYSFS_read(f, buf2 + left, 1, right) != right)

                    {

                        printf("PHYSFS_read() failed: %s.\n", PHYSFS_getLastError());

                        PHYSFS_close(f);

                        return(1);

                    } /* if */

                    rndnum = 1 + (int) (1000.0 * rand() / (RAND_MAX + 1.0));

                    if (rndnum == 42)

                    {

                        if (!PHYSFS_flush(f))

                        {

                            printf("PHYSFS_flush() failed: %s.\n", PHYSFS_getLastError());

                            PHYSFS_close(f);

                            return(1);

                        } /* if */

                    } /* if */

                    if (memcmp(buf, buf2, 36) != 0)

                    {

                        printf("readback is mismatched on iterations (%d, %d).\n", i, j);

                        printf("wanted: [");

                        for (i = 0; i < 36; i++)

                            printf("%c", buf[i]);

                        printf("]\n");

                        printf("   got: [");

                        for (i = 0; i < 36; i++)

                            printf("%c", buf2[i]);

                        printf("]\n");

                        PHYSFS_close(f);

                        return(1);

                    } /* if */

                } /* for */

                if (!PHYSFS_flush(f))

                {

                    printf("PHYSFS_flush() failed: %s.\n", PHYSFS_getLastError());

                    PHYSFS_close(f);

                    return(1);

                } /* if */

            } /* for */