/************************************************************************
 *
 * 0.fnmatch.cpp - tests exercising the rw_fnmatch() helper function
 *
 * $Id$
 *
 ************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 **************************************************************************/

#include <rw_fnmatch.h>   // for rw_fnmatch()
#include <stdio.h>        // for fprintf(), stderr


#ifdef _RWSTD_OS_LINUX
#  include <fnmatch.h>    // for fnmatch()
#  define FNMATCH(pat, str, arg) fnmatch (pat, str, arg)
#endif   // _RWSTD_OS_LINUX


// the number of failed tests
static int nerrors;

static void
test (int line, int exp, const char *pat, const char *str)
{
    const int result = rw_fnmatch (pat, str, 0);

#ifdef FNMATCH
    const int native = FNMATCH (pat, str, 0);
#else   // if !defined (FNMATCH)
    const int native = exp;
#endif   // FNMATCH

    if (result != native || -1 < exp && result != exp) {

        ++nerrors;

        fprintf (stderr,
                 "%d. rw_fnmatch(\"%s\", \"%s\", 0) ==> %d, "
                 "expected (native:own) %d:%d\n",
                 line, pat, str, result, native, exp);
    }
}


int main ()
{
#define TEST(exp, pat, str) test (__LINE__, exp, pat, str)

    TEST (0, "",  "");
    TEST (1, "",  "a");
    TEST (1, "a", "");

    TEST (0, "a", "a");
    TEST (1, "a", "b");

    TEST (0, "ab", "ab");
    TEST (1, "ab", "ac");

    TEST (0, "abc", "abc");
    TEST (1, "xbc", "abc");
    TEST (1, "ayc", "abc");
    TEST (1, "abz", "abc");

    // exercise escaped characters
    TEST (1, "\\a", "");
    TEST (0, "\\a", "a");
    TEST (1, "\\a", "\\a");
    TEST (1, "\\\\", "");
    TEST (0, "\\\\", "\\");
    TEST (1, "\\?", "\\a");
    TEST (0, "\\?", "?");
    TEST (1, "\\?", "\\?");
    TEST (0, "\\[", "[");
    TEST (1, "\\[", "\\[");
    TEST (0, "\\[a", "[a");
    TEST (0, "\\[a]", "[a]");
    TEST (0, "\\[a\\]", "[a]");
    TEST (0, "\\[\\a\\]", "[a]");

    // exercise the question mark pattern
    TEST (1, "?", "");
    TEST (0, "?", "a");
    TEST (1, "?", "ab");

    TEST (1, "\\?", "");
    TEST (1, "\\?", "a");
    TEST (0, "\\?", "?");

    TEST (0, "a?", "ad");
    TEST (0, "?b", "ab");
    TEST (1, "?b", "ac");
    TEST (0, "??", "ae");
    TEST (1, "??", "aef");

    TEST (0, "?bc", "abc");
    TEST (0, "a?c", "abc");
    TEST (0, "ab?", "abc");

    TEST (0, "??c", "abc");
    TEST (0, "a??", "abc");
    TEST (0, "?b?", "abc");

    TEST (1, "??c", "abz");
    TEST (1, "a??", "xbc");
    TEST (1, "?b?", "ayc");

    TEST (0, "???", "abc");
    TEST (1, "???", "ab");
    TEST (1, "???", "abcd");

    // exercise the asterisk pattern
    TEST (0, "*", "");
    TEST (0, "*", "a");
    TEST (0, "*", "ab");
    TEST (0, "*", "abc");

    TEST (1, "\\*", "");
    TEST (1, "\\*", "a");
    TEST (0, "\\*", "*");
    TEST (1, "\\*", "ab");
    TEST (1, "\\*", "abc");

    TEST (0, "**", "");
    TEST (0, "**", "a");
    TEST (0, "**", "ab");
    TEST (0, "**", "abc");

    TEST (1, "*\\*", "");
    TEST (1, "*\\*", "a");
    TEST (0, "*\\*", "a*");
    TEST (0, "*\\*", "ab*");

    TEST (1, "a*", "");
    TEST (0, "a*", "a");
    TEST (0, "a*", "ab");
    TEST (0, "a*", "abc");

    TEST (1, "a**", "");
    TEST (0, "a**", "a");
    TEST (0, "a**", "ab");
    TEST (0, "a**", "abc");

    TEST (1, "**c", "");
    TEST (1, "**c", "a");
    TEST (1, "**c", "ab");
    TEST (0, "**c", "abc");
    TEST (1, "**c", "abcd");

    TEST (1, "a*z", "");
    TEST (1, "a*z", "a");
    TEST (1, "a*z", "ab");
    TEST (1, "a*z", "abc");
    TEST (0, "a*z", "abcz");
    TEST (0, "a*z", "abcdz");
    TEST (0, "a*z", "abcdez");

    TEST (1, "ab*z", "");
    TEST (1, "ab*z", "a");
    TEST (1, "ab*z", "ab");
    TEST (1, "ab*z", "abc");
    TEST (0, "ab*z", "abcz");
    TEST (0, "ab*z", "abcdz");
    TEST (0, "ab*z", "abcdez");

    TEST (1, "a*yz", "");
    TEST (1, "a*yz", "a");
    TEST (1, "a*yz", "ab");
    TEST (1, "a*yz", "abc");
    TEST (1, "a*yz", "abcz");
    TEST (0, "a*yz", "abcyz");
    TEST (0, "a*yz", "abcdyz");

    TEST (1, "ab*yz", "");
    TEST (1, "ab*yz", "a");
    TEST (1, "ab*yz", "ab");
    TEST (1, "ab*yz", "abc");
    TEST (1, "ab*yz", "abcz");
    TEST (0, "ab*yz", "abcyz");
    TEST (0, "ab*yz", "abcdyz");
    TEST (0, "ab*yz", "abcdeyz");

    TEST (1, "ab*x*z", "");
    TEST (1, "ab*x*z", "a");
    TEST (1, "ab*x*z", "ab");
    TEST (1, "ab*x*z", "abc");
    TEST (1, "ab*x*z", "abcz");
    TEST (1, "ab*x*z", "abcyz");
    TEST (0, "ab*x*z", "abcxyz");
    TEST (0, "ab*x*z", "abcxxyz");
    TEST (0, "ab*x*z", "abcxyyz");

    TEST (1, "*b*x*z", "");
    TEST (1, "*b*x*z", "a");
    TEST (1, "*b*x*z", "ab");
    TEST (1, "*b*x*z", "abc");
    TEST (1, "*b*x*z", "abcz");
    TEST (1, "*b*x*z", "abcyz");
    TEST (0, "*b*x*z", "bcxyz");
    TEST (0, "*b*x*z", "abcxyz");
    TEST (0, "*b*x*z", "aabcxyz");
    TEST (0, "*b*x*z", "abcxxyz");
    TEST (0, "*b*x*z", "abcxyyz");

    TEST (1, "abc*klm*xyz", "");
    TEST (1, "abc*klm*xyz", "a");
    TEST (1, "abc*klm*xyz", "ak");
    TEST (1, "abc*klm*xyz", "akx");

    TEST (1, "abc*klm*xyz", "abkx");
    TEST (1, "abc*klm*xyz", "abklx");
    TEST (1, "abc*klm*xyz", "abklxy");
    TEST (1, "abc*klm*xyz", "abcklxy");
    TEST (1, "abc*klm*xyz", "abcklmxy");
    TEST (0, "abc*klm*xyz", "abcklmxyz");
    TEST (0, "abc*klm*xyz", "abcdklmxyz");
    TEST (0, "abc*klm*xyz", "abcdklmnxyz");

    // exercise simple bracket expressions
    TEST (1, "[a]", "");
    TEST (0, "[a]", "a");
    TEST (1, "[a]", "b");
    TEST (1, "[?]", "c");
    TEST (0, "[?]", "?");
    TEST (1, "[-]", "d");
    TEST (0, "[-]", "-");
    TEST (1, "[]]", "e");
    TEST (0, "[]]", "]");
    TEST (1, "[\\]]", "f");
    TEST (1, "[\\]]", "\\");
    TEST (0, "[\\]]", "]");

    TEST (1, "[\\!a]", "");
    TEST (0, "[\\!a]", "a");
    TEST (1, "[\\!a]", "b");
    TEST (0, "[\\!?]", "!");
    TEST (0, "[\\!?]", "?");
    TEST (0, "[\\!-]", "-");
    TEST (0, "[\\!!]", "!");
    TEST (0, "[\\\\!]", "\\");

    TEST (1, "[ab]", "");
    TEST (0, "[ab]", "a");
    TEST (0, "[ab]", "b");
    TEST (1, "[ab]", "c");

    TEST (1, "[a]b", "");
    TEST (1, "[a]b", "a");
    TEST (0, "[a]b", "ab");
    TEST (1, "[a]b", "b");

    TEST (1, "a[b]", "");
    TEST (1, "a[b]", "a");
    TEST (0, "a[b]", "ab");
    TEST (1, "a[b]", "b");

    TEST (1, "a[bc]", "");
    TEST (1, "a[bc]", "a");
    TEST (0, "a[bc]", "ab");
    TEST (0, "a[bc]", "ac");
    TEST (1, "a[bc]", "abc");
    TEST (1, "a[\\]]", "ab");
    TEST (0, "a[\\]]", "a]");

    TEST (1, "[abc]", "");
    TEST (0, "[abc]", "a");
    TEST (0, "[abc]", "b");
    TEST (0, "[abc]", "c");
    TEST (1, "[abc]", "ab");
    TEST (1, "[abc]", "ac");
    TEST (1, "[abc]", "abc");

    // exercise negated bracket expressions
    TEST (1, "[!a]", "");
    TEST (1, "[!a]", "a");
    TEST (0, "[!a]", "b");
    TEST (1, "[!?]", "?");
    TEST (0, "[!?]", "c");
    TEST (1, "[!-]", "-");
    TEST (0, "[!-]", "d");
    TEST (1, "[!!]", "!");
    TEST (0, "[!!]", "e");

    TEST (1, "[!ab]", "");
    TEST (1, "[!ab]", "a");
    TEST (1, "[!ab]", "b");
    TEST (0, "[!ab]", "c");

    TEST (1, "[!a]b", "");
    TEST (1, "[!a]b", "a");
    TEST (1, "[!a]b", "ab");
    TEST (1, "[!a]b", "b");
    TEST (0, "[!a]b", "bb");

    TEST (1, "a[!b]", "");
    TEST (1, "a[!b]", "a");
    TEST (1, "a[!b]", "ab");
    TEST (1, "a[!b]", "b");
    TEST (0, "a[!b]", "ac");

    TEST (1, "a[!bc]", "");
    TEST (1, "a[!bc]", "a");
    TEST (1, "a[!bc]", "ab");
    TEST (1, "a[!bc]", "ac");
    TEST (0, "a[!bc]", "ad");
    TEST (0, "a[!!?]", "ae");
    TEST (0, "a[!?!]", "af");
    TEST (0, "a[!?-]", "ag");
    TEST (0, "a[!-?]", "ah");
    TEST (1, "a[!bc]", "aae");
    TEST (1, "a[!bc]", "abe");
    TEST (1, "a[!bc]", "ace");

    TEST (1, "[!abc]", "");
    TEST (1, "[!abc]", "a");
    TEST (1, "[!abc]", "b");
    TEST (1, "[!abc]", "c");
    TEST (0, "[!abc]", "d");
    TEST (1, "[!abc]", "ab");
    TEST (1, "[!abc]", "ac");
    TEST (1, "[!abc]", "ad");
    TEST (1, "[!abc]", "abc");
    TEST (1, "[!abc]", "abcd");

    TEST (1, "[!abc]d", "");
    TEST (1, "[!abc]d", "a");
    TEST (1, "[!abc]d", "b");
    TEST (1, "[!abc]d", "c");
    TEST (1, "[!abc]d", "d");
    TEST (0, "[!abc]d", "dd");
    TEST (1, "[!abc]d", "ab");
    TEST (1, "[!abc]d", "ac");
    TEST (1, "[!abc]d", "ad");
    TEST (1, "[!abc]d", "abc");
    TEST (1, "[!abc]d", "abcd");

    // exercise bracket expressions with ranges
    TEST (1, "[a-a]", "");
    TEST (0, "[a-a]", "a");
    TEST (1, "[a-a]", "b");
    TEST (1, "[a-a]", "ab");
    TEST (1, "[a-a]", "ba");

    TEST (1, "[a-b]", "");
    TEST (0, "[a-b]", "a");
    TEST (0, "[a-b]", "b");
    TEST (1, "[a-b]", "c");

    TEST (1, "[a-c]", "");
    TEST (0, "[a-c]", "a");
    TEST (0, "[a-c]", "b");
    TEST (0, "[a-c]", "c");
    TEST (1, "[a-c]", "d");

    TEST (1, "[a-ce]", "");
    TEST (0, "[a-ce]", "a");
    TEST (0, "[a-ce]", "b");
    TEST (0, "[a-ce]", "c");
    TEST (1, "[a-ce]", "d");
    TEST (0, "[a-ce]", "e");
    TEST (1, "[a-ce]", "f");

    TEST (1, "[ac-e]", "");
    TEST (0, "[ac-e]", "a");
    TEST (1, "[ac-e]", "b");
    TEST (0, "[ac-e]", "c");
    TEST (0, "[ac-e]", "d");
    TEST (0, "[ac-e]", "e");
    TEST (1, "[ac-e]", "f");

    TEST (1, "[ac-eg]", "");
    TEST (0, "[ac-eg]", "a");
    TEST (1, "[ac-eg]", "b");
    TEST (0, "[ac-eg]", "c");
    TEST (0, "[ac-eg]", "d");
    TEST (0, "[ac-eg]", "e");
    TEST (1, "[ac-eg]", "f");
    TEST (0, "[ac-eg]", "g");

    TEST (1, "[ac-egk-m]", "");
    TEST (0, "[ac-egk-m]", "a");
    TEST (1, "[ac-egk-m]", "b");
    TEST (0, "[ac-egk-m]", "c");
    TEST (0, "[ac-egk-m]", "d");
    TEST (0, "[ac-egk-m]", "e");
    TEST (1, "[ac-egk-m]", "f");
    TEST (0, "[ac-egk-m]", "g");
    TEST (1, "[ac-egk-m]", "h");
    TEST (1, "[ac-egk-m]", "i");
    TEST (1, "[ac-egk-m]", "j");
    TEST (0, "[ac-egk-m]", "k");
    TEST (0, "[ac-egk-m]", "l");
    TEST (0, "[ac-egk-m]", "m");
    TEST (1, "[ac-egk-m]", "n");

    TEST (1, "[1-9][0-9]", "");
    TEST (1, "[1-9][0-9]", "0");
    TEST (1, "[1-9][0-9]", "1");
    TEST (1, "[1-9][0-9]", "2");
    TEST (1, "[1-9][0-9]", "00");
    TEST (1, "[1-9][0-9]", "01");
    TEST (0, "[1-9][0-9]", "10");
    TEST (0, "[1-9][0-9]", "11");
    TEST (0, "[1-9][0-9]", "12");
    TEST (0, "[1-9][0-9]", "90");
    TEST (0, "[1-9][0-9]", "99");
    TEST (1, "[1-9][0-9]", "999");

    TEST (1, "[1-9].[0-9]", "0.1");
    TEST (0, "[1-9].[0-9]", "1.0");
    TEST (1, "[1-9].[0-9]", "1.0.0");

    // exercise mixed patterns
    TEST (1, "[1-9].[0-9]*", "1.");
    TEST (0, "[1-9].[0-9]*", "1.2");
    TEST (0, "[1-9].[0-9]*", "1.23");
    TEST (0, "[1-9].[0-9]*", "1.2x");
    TEST (0, "[1-9]?[0-9]*", "1-2y");

    TEST (1, "*-aix[1-9].[0-9]-xlc7.0.0.[0-9]", "ppc-aix4.3-xlc6.0");
    TEST (1, "*-aix[1-9].[0-9]-xlc7.0.0.[0-9]", "ppc-aix5.2-xlc6.0");
    TEST (0, "*-aix[1-9].[0-9]-xlc7.0.0.[0-9]", "ppc-aix4.3-xlc7.0.0.0");

    // exercise incomplete patterns
    TEST (1, "\\", "");
    TEST (1, "\\", "a");
    TEST (1, "\\", "\\");
    TEST (1, "[",  "");
    TEST (1, "[",  "a");
    TEST (1, "[",  "[");
    TEST (1, "[a", "");
    TEST (1, "[a", "[a");

    // return 0 on success, 1 on failure
    return !(0 == nerrors);
}