---

/home/vlg/develop/gwavmerger/tests/test.cpp

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                          str_parse_test.cpp
//------------------------------------------------------------------------------
// $Id: test.cpp,v 1.1 2003/02/07 05:15:10 vlg Exp $
//------------------------------------------------------------------------------
//  Copyright (c) 2001,2002 by Vladislav Grinchenko
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version
//  2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------

/*******************************************************************************
 Parse format from a fully qualified sequence of names. A fully quialified
 name is of the format:

    <prefix><number>.wav

 The sequence might have "gap" entires which are ignored.

 For example, ru_034.wav is a fully qualified name with
 
     <prefix>="ru_"
     <number>="034" 

 The printf format of this name is "%03d".

 Return: format if successful; If format is not uniform, but otherwise
         valid, "%d" is returned.

         empty string if failed. An empty string is resulted in
         case if not all names in sequence have the same prefix.

*******************************************************************************/
string
parse_format (const string& prefix_, vector<string>& vs_)
{
    string ret;
    int i = 0;
    bool is_varlen = false;
    int len = 0;
    bool is_numeric = true;
    string name;

    vector<string>::const_iterator cit = vs_.begin ();
    name = parse_seq_number (*cit, prefix_);

    if ((len = name.length ()) == 0) {
        return ret;
    }

    while (cit != vs_.end ()) {
        if (*cit != "gap") {
            name = parse_seq_number (*cit, prefix_);
            if (name.length () == 0) {
                return ret;
            }
            i = strtol (name.c_str (), (char **) NULL, 10);
            if (i == LONG_MIN || i == LONG_MAX) {
                is_numeric = false;
                break;
            }
            if (name.length () != len) {
                is_varlen = true;
            }
        }
        cit++;
    }
    if (is_numeric) {
        if (!is_varlen) {
            ostringstream os;
            os << "%0" << len << "d";
            ret = os.str ();
        }
        else {
            ret = "%d";
        }
    }
    return ret;
}

/*******************************************************************************
 Extract the sequence number from a file name. A file name is of the format:

    <prefix><seq_number>.wav

 For example, ru_034.wav is a fully qualified name with
 
     <prefix>="ru_"
     <seq_number>="034" 

 Return: parsed <seq_number> if success; 
         empty string if failed
*******************************************************************************/
string
parse_seq_number (const string& name_, const string& prefix_)
{
    string s (name_);
    string::size_type idx = string::npos;

    if ((idx = s.find (prefix_)) == 0) {
        s.erase (0, prefix_.length ());
        idx = s.find ('.');
        if (idx != string::npos) {
            if (s.substr (idx) == ".wav") {
                s.replace (idx, name_.size (), "");
                return s;
            }
        }
    }
    return ("");
}


/*******************************************************************************
 Format sequence number according to the supplied format.
 For example, if seqnum = 34 and format "%03d" the result will be 034.

 Return: formatted sequence number.
*******************************************************************************/
string
format_seqnum (int seqnum_, const string& fmt_)
{
    char buf [PATH_MAX];

    snprintf (buf, PATH_MAX, fmt_.c_str (), seqnum_);
    return string (buf);
}

/*******************************************************************************
 Take fully qualified file name in form <prefix><seq_number>.wav and make a 
 fully qualified name of the file with offset
    <path>/<prefix><seq_number+offset>.wav

 Return: fully qualified name or an empty string if parsing sequence number
         failed.
*******************************************************************************/
string
make_name_with_offset (const string& name_, const string& fmt_,
                       const string& prefix_, const string& dirpath_, 
                       int offset_)
{
    string s (name_);
    string::size_type idx;

    cout << '\n';
    s = parse_seq_number (s, prefix_);
    cout << "\tparsed sequence number: " << s << '\n';
    if (s.length () == 0) {
        return s;
    }
    return (dirpath_ + prefix_ 
            + format_seqnum (atoi (s.c_str ()) + offset_, fmt_) 
            + string (".wav"));
}

/*******************************************************************************
 Take file name in form <path>/<prefix><seq_number>.wav and make a fully 
 qualified name of the file that follows: <path>/<prefix><seq_number-1>.wav

 Return: fully qualified name or an empty string if parsing sequence number
         failed.
*******************************************************************************/
string
make_prev_name (const string& name_, const string& fmt_,
                const string& prefix_, const string& dirpath_)
{
    return make_name_with_offset (name_, fmt_, prefix_, dirpath_, -1);
}

/*******************************************************************************
 Take file name in form <path>/<prefix><seq_number>.wav and make a fully 
 qualified name of the file that follows: <path>/<prefix><seq_number+1>.wav

 Return: fully qualified name or an empty string if parsing sequence number
         failed.
*******************************************************************************/
string
make_next_name (const string& name_, const string& fmt_,
                const string& prefix_, const string& dirpath_)
{
    return make_name_with_offset (name_, fmt_, prefix_, dirpath_, +1);
}
    
/******************************************************************************/

static const char* list[]={ 
    "ru_001.wav", "ru_002.wav", "ru_003.wav", 
    "ru_004.wav", "ru_005.wav", NULL 
};

static const char* list_non_uniform_format[]={ 
    "ru_001.wav", "ru_2.wav", "ru_003.wav", 
    "ru_004.wav", "ru_005.wav", NULL 
};

static const char* list_with_gaps []={ 
    "ru_001.wav", "gap", "ru_003.wav", 
    "ru_004.wav", "gap", "ru_006.wav", NULL 
};

static const char* list_bad_format []={ 
    "ru_001.wav", "en_002.wav", "ru_003.wav", 
    "ru_004.wav", "", "ru_006.wav", NULL 
};

/******************************************************************************/

int 
main()
{
    int i;
    string format;
    vector<string> v;

    cout << '\n' << "Testing parse_format() ...";

    i = 0;
    while (list [i]) { v.push_back (list [i++]); }

    format = parse_format ("ru_", v);
    if (format != "%03d") {
        cout << "failed valid list\n";
        cout << "(expected \"%03\", returned \"" << format << "\"\n\n";
        return 1;
    }
    
    v.clear ();
    i = 0;
    while (list_with_gaps [i]) { v.push_back (list_with_gaps [i++]); }

    format = parse_format ("ru_", v);
    if (format != "%03d") {
        cout << "failed list with gaps\n";
        return 1;
    }

    v.clear ();
    i = 0;
    while (list_non_uniform_format [i]) { 
        v.push_back (list_non_uniform_format [i++]); 
    }

    format = parse_format ("ru_", v);
    if (format != "%d") {
        cout << "failed list with non-uniform format\n";
        cout << "(expected \"\", returned \"" << format << "\"\n\n";
        return 1;
    }
    v.clear ();

    i = 0;
    while (list_bad_format [i]) { 
        v.push_back (list_bad_format [i++]); 
    }

    format = parse_format ("ru_", v);
    if (format != "") {
        cout << "failed list with bad format\n";
        cout << "(expected \"\", returned \"" << format << "\"\n\n";
        return 1;
    }
    cout << "ok\n";

    cout << "\nTesting parse_seq_num() ";
    string res;
    string name;
    name = "ru_00034.wav";
    res = parse_seq_number (name, "ru_");
    if (res != "00034") {
        cout << "failed (expected \"00034\", returned \"" << res << "\"\n\n";
        return 1;
    }
    res = parse_seq_number (name, "en_");
    if (res != "") {
        cout << "failed (expected \"\", returned \"" << res << "\"\n\n";
        return 1;
    }
    name = "ru_0999";
    res = parse_seq_number (name, "ru_");
    if (res != "") {
        cout << "failed (expected \"\", returned \"" << res << "\"\n\n";
        return 1;
    }
    name = "ru_0999.wav";
    res = parse_seq_number (name, "ru_");
    if (res != "0999") {
        cout << "failed (expected \"0999\", returned \"" << res << "\"\n\n";
        return 1;
    }
    cout << "ok\n";

    cout << "\nTesting format_seqnum () ";
    res = format_seqnum (54, "%03d");
    if (res != "054") {
        cout << "failed (expected \"054\", returned \"" << res << "\"\n\n";
        return 1;
    }

    res = format_seqnum (54, "%d");
    if (res != "54") {
        cout << "failed (expected \"54\", returned \"" << res << "\"\n\n";
        return 1;
    }
    cout << "ok\n";

    cout << "\nTesting make_name_with_offset () ";
    string dirpath ("/English/Test/");
    format = "%04d";
    name = "ru_0999.wav";
    res = make_name_with_offset (name, format, "ru_", dirpath, 0);

    if (res != dirpath + "ru_0999.wav") {
        cout << "failed\n\t(expected \"/English/Test/ru_0999.wav\""
             << ", returned \"" << res << "\")\n\n";
        return 1;
    }
    cout << "ok\n";

    cout << "\nTesting make_prev_name () ";
    res = make_prev_name (name, format, "ru_", dirpath);
    if (res != dirpath + "ru_0998.wav") {
        cout << "failed\n\t(expected \"/English/Test/ru_0998.wav\""
             << ", returned \"" << res << "\")\n\n";
        return 1;
    }
    res.erase (0, dirpath.length ());
    name = res;
    res = make_prev_name (name, format, "ru_", dirpath);
    if (res != dirpath + "ru_0997.wav") {
        cout << "failed\n\t(expected \"/English/Test/ru_0997.wav\""
             << ", returned \"" << res << "\")\n\n";
        return 1;
    }
    cout << "ok\n";

    cout << "\n";
}

---