main.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "client.h"
#include "utils.h"

#define INIT_REPO  "init_test_repo"

/****** Convenience functions. *******/

void setup_tmp()
{
        system("hg init tmp");
        chdir("tmp");
}

void clean_tmp()
{
        chdir("..");
        system("rm -rf tmp");
}

void setup_init()
{
        system("mkdir tmp");
        chdir("tmp");
}

void post_init_setup()
{
        chdir(INIT_REPO);
        system("touch foo ; hg add foo ; hg commit -m foo");
        system("echo baloo > foo ; hg commit -m 'baloo text'");
        chdir("..");
}

void setup_log()
{
        system("touch foo ; hg add foo ; hg commit -m foo");
        system("echo baloo > foo ; hg commit -m 'baloo text'");
        system("touch voodoo ; hg add voodoo ; hg commit -m voodoo");
        system("echo voodoo > voodoo ; hg commit -m 'voodoo text'");
}

void setup_merge()
{
        system("touch foo ; hg add foo ; hg commit -m foo");
        system("echo baloo > foo ; hg commit -m 'baloo text'");
        system("hg up 0");
        system("touch boo ; hg add boo ; hg commit -m boo");
        system("echo voodoo > boo ; hg commit -m 'voodoo text'");
}

void setup_conflict_merge()
{
        system("touch foo ; hg add foo ; hg commit -m foo");
        system("echo baloo > foo ; hg commit -m 'baloo text'");
        system("hg up 0");
        system("echo voodoo > foo ; hg commit -m 'voodoo text'");
}

void setup_export_import()
{
        system("hg init export");
        chdir("export");
        system("touch foo ; echo baloo > foo; hg add foo ; hg commit -m foo");
        chdir("..");
        system("hg init import");
}

void clean_export_import()
{
        system("rm -rf export import");
}

void setup_filename_with_space()
{
        system("touch 'foo bar'");
        printf("---- ls command ----\n");
        system("ls -l");
}

/******* By hand implementations. ******/

hg_handle *hg_init_by_hand()
{
        pid_t cpid;
        int status;
        hg_handle *handle;
        char command[50];

        sprintf(command, "hg init %s", INIT_REPO);

        if((cpid = fork()) < 0) {
                printf("Fork failed\n");
                return NULL;

        } else if(cpid == 0) {
                execl("/bin/sh", "sh", "-c", command, NULL);
                printf("dadads\n\n");
        } else {
                 waitpid( cpid, &status, 0);
        }

        handle = hg_open(INIT_REPO, "");

        return handle;
}

int hg_log_by_hand(hg_handle *handle)
{
        char buff[4096];
        char *comm[] = {"log", "-v"};
        int exitcode;
        int ns;

        hg_rawcommand(handle, comm, 2);

        while(hg_channel(handle) != 'r'){
                while(ns = hg_rawread(handle, buff, 4096), ns > 0){
                        printf("%s", buff);
                }
        }

        exitcode = hg_exitcode(handle);
        printf("exitcode = %d\n", exitcode);

        return exitcode;
}

int hg_import_by_hand(hg_handle *handle, char *import_patch)
{
        char *comm[] = {"import", "-"};
        char buff[4096];
        int exitcode = 0;
        int fd, ns;
        hg_header header;

        fd = open(import_patch, O_RDONLY);
        hg_rawcommand(handle, comm, 2);

        while(hg_channel(handle) != 'r'){
                /* outchannels 'o' or 'e'. */
                while(ns = hg_rawread(handle, buff, 4096), ns > 0){
                        printf("%s", buff);
                }
                if(hg_channel(handle) == 'L'){
                        header = hg_head(handle);
                        int length = read(fd, buff, header.length);
                        hg_rawwrite(handle, buff, length);
                }
        }

        exitcode = hg_exitcode(handle);
        return exitcode;
}

char prompt_function(char *output)
{
        char option;
        scanf("\n%c", &option);
        return option;
}

int hg_merge_by_hand(hg_handle *handle, char (*prompt)(char *))
{
        char *comm[] = {"merge", "--tool=internal:prompt"};
        char buff[4096];
        int exitcode = 0;
        int ns;

        hg_rawcommand(handle, comm, 2);

        while(hg_channel(handle) != 'r'){
                /* outchannels 'o' or 'e'. */
                while(ns = hg_rawread(handle, buff, 4096), ns > 0){
                        printf("%s", buff);
                }
                if(hg_channel(handle) == 'I'){
                        printf("INPUT\n");
                }
                else if(hg_channel(handle) == 'L'){
                        /* In stand of the default prompt_msg, the argument for 
                         * prompt function will be the output data received
                         * until this moment.
                         * */
                        char option = (*prompt)(NULL);
                        printf("\noption = %c\n", option);
                        hg_rawwrite(handle, &option, 1);
                        /* TODO: is a small issue, but not for this level.
                         * The second write, must not be necessary.
                         * */
                        hg_rawwrite(handle, &option, 0);
                }
        }

        exitcode = hg_exitcode(handle);
        printf("exitcode = %d\n", exitcode);

        return exitcode;
}

int hg_verify_by_hand(hg_handle *handle)
{
        char *comm[] = {"verify"};
        char buff[4096];
        int exitcode = 0;
        int ns;

        hg_rawcommand(handle, comm, 1);

        while(hg_channel(handle) != 'r'){
                while(ns = hg_rawread(handle, buff, 4096), ns > 0){
                        if(hg_channel(handle) == 'o'){
                                printf("out = %s", buff);
                        }
                        else if(hg_channel(handle) == 'e'){
                                printf("err = %s", buff);
                        }
                }
        }

        exitcode = hg_exitcode(handle);
        printf("exitcode = %d\n", exitcode);

        return exitcode;
}

void hg_export_import_by_hand(hg_handle *ehandle, hg_handle *ihandle)
{
        char *export_comm[] = {"export", "-r", "0"};
        char *import_comm[] = {"import", "-"};
        char ebuff[4096], ibuff[4096];
        int es, is;

        hg_rawcommand(ehandle, export_comm, 3);
        hg_rawcommand(ihandle, import_comm, 2);

        while(hg_channel(ehandle) != 'r'){
                while(es = hg_rawread(ehandle, ebuff, 4096), es > 0){
                        while(is = hg_rawread(ihandle, ibuff, 4096), is > 0){
                                printf("%s", ibuff);
                        }
                        if(hg_channel(ihandle) == 'L'){
                                hg_rawwrite(ihandle, ebuff, strlen(ebuff));
                        }
                }
        }
        /* Send a message to ihandle to understand that the import process
         * was ending*/
        hg_rawwrite(ihandle, ebuff, 0);

        while(hg_channel(ihandle) != 'r'){
                while(is = hg_rawread(ihandle, ibuff, 4096), is > 0){
                        printf("%s", ibuff);
                }
        }

        printf("exitcode for export process is %d \n", hg_exitcode(ehandle));
        printf("exitcode for import process is %d \n", hg_exitcode(ihandle));

}

int hg_add_filename_with_space_by_hand(hg_handle *handle)
{
        char buff[4096];
        char *comm[] = {"add", "foo bar"};
        int exitcode;
        int ns;

        hg_rawcommand(handle, comm, 2);

        while(hg_channel(handle) != 'r'){
                while(ns = hg_rawread(handle, buff, 4096), ns > 0){
                        printf("%s", buff);
                }
        }

        exitcode = hg_exitcode(handle);
        printf("exitcode = %d\n", exitcode);

        return exitcode;
}

void print_select_case()
{
        printf("Select test case to run:\n");
        printf("0) init - 'make some commits' & log \n");
        printf("1) log \n");
        printf("2) import - from stdin (simulate from a file) \n");
        printf("3) merge - (solve conflicts from stdin) \n");
        printf("4) merge - (without conflicts)\n");
        printf("5) verify \n");
        printf("6) verify a corrupt repo.\n");
        printf("7) export-import example.\n");
        printf("8) add 'filename with space'\n");
        printf("\n");
        printf("Your choice: ");
}


/***** Main function. *******/
int main(int argc, char **argv)
{
        int select_case;
        hg_handle *handle;
        hg_handle *ehandle, *ihandle;

        print_select_case();
        scanf("%d", &select_case);
        if(select_case < 0 || select_case > 8){
                printf("Your choice is not an option...\n");
                return -1;
        }

        switch(select_case){
                case 0:
                        setup_init();
                        handle = hg_init_by_hand();
                        post_init_setup();
                        hg_log_by_hand(handle);

                        hg_close(&handle);
                        clean_tmp();
                        break;
                case 1:
                        setup_tmp();
                        setup_log();
                        handle = hg_open(NULL, "");
                        hg_log_by_hand(handle);

                        hg_close(&handle);
                        clean_tmp();
                        break;
                case 2:
                        setup_export_import();
                        ihandle = hg_open("import", "");

                        chdir("export");
                        system("hg export -r 0 > r0.diff");
                        chdir("..");
                        hg_import_by_hand(ihandle, "export/r0.diff");

                        printf("\n");
                        hg_log_by_hand(ihandle);

                        hg_close(&ihandle);
                        clean_export_import();
                        break;
                case 3:
                case 4:
                        setup_tmp();
                        if(select_case == 3)
                                setup_conflict_merge();
                        else
                                setup_merge();
                        handle = hg_open(NULL, "");
                        hg_merge_by_hand(handle, prompt_function);
                        system("hg ci -m 'merge'");
                        system("hg glog");

                        hg_close(&handle);
                        clean_tmp();
                        break;
                case 5:
                case 6:
                        setup_tmp();
                        setup_log();
                        handle = hg_open(NULL, "");
                        printf("\n");
                        if(select_case == 6)
                                system("rm .hg/store/data/foo.i");
                        hg_verify_by_hand(handle);

                        hg_close(&handle);
                        clean_tmp();
                        break;
                case 7:
                        setup_export_import();
                        ehandle = hg_open("export", "");
                        ihandle = hg_open("import", "");
                        hg_export_import_by_hand(ehandle, ihandle);
                        hg_close(&ehandle);
                        hg_close(&ihandle);
                        clean_export_import();
                        break;
                case 8:
                        setup_tmp();
                        setup_filename_with_space();
                        printf("\n");
                        handle = hg_open(NULL, "");
                        hg_add_filename_with_space_by_hand(handle);
                        printf("\n---- hs status command ----\n");
                        system("hg status");
                        clean_tmp();
                        break;
                default:
                        break;
        }

        return 0;
}