src/testcases/HelperTest.cpp

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

// before including helper.h, pretend to be Windows to enable the drive (c:\) handling routines ...
#define _WIN32
// ... but at the same time force forward slash as our path separator for our tests
#define NATIVE_PATH_SEPARATOR '/'

#include "../helper.h"

int main() {
    int iErrors = 0;

    // test cases for function strip2ndFromEndOf1st()
    {
        // (a) input string, (b) expected result string
        std::pair<std::string, std::string> examples[] = {
            { "", "" },
            { "/", "" },
            { "//", "" },
            { "///", "" },
            { "/foo/bla", "/foo/bla" },
            { "/foo/bla/", "/foo/bla" },
            { "/foo/bla//", "/foo/bla" },
            { "/foo/bla///", "/foo/bla" },
            { "/foo", "/foo" },
            { "/foo/", "/foo" },
            { "/foo//", "/foo" },
            { "/foo///", "/foo" },
            { "/foo/asdf.gig", "/foo/asdf.gig" },
            { "foo", "foo" },
            { "asdf.gig", "asdf.gig" },
            { "C:/", "C:" },
            { "C://", "C:" },
            { "C:", "C:" },
            { "C:/asdf", "C:/asdf" },
            { "C:/asdf/", "C:/asdf"},
            { "C:/asdf//", "C:/asdf"},
            { "C:/asdf///", "C:/asdf"},
        };
        for (auto ex : examples) {
            const std::string in  = ex.first;
            const std::string out = strip2ndFromEndOf1st(in, '/');
            const std::string expected = ex.second;
            if (out != expected) iErrors++;
            printf("strip2ndFromEndOf1st('%s', '/')  =>  '%s' [%s]\n",
                   in.c_str(), out.c_str(),
                   ((out == expected) ? "ok" : "WRONG")
            );
        }
    }

    // test cases for function parentPath()
    {
        // (a) input string, (b) expected result string
        std::pair<std::string, std::string> examples[] = {
            { "", "" },
            { "/", "/" },
            { "//", "/" },
            { "///", "/" },
            { "/foo/bla", "/foo" },
            { "/foo/bla/", "/foo" },
            { "/foo/bla//", "/foo" },
            { "/foo/bla///", "/foo" },
            { "/foo", "/" },
            { "/foo/", "/" },
            { "/foo//", "/" },
            { "/foo///", "/" },
            { "/foo/asdf.gig", "/foo" },
            { "foo", "" },
            { "asdf.gig", "" },
            { "C:", "C:" },
            { "C:/", "C:" },
            { "C://", "C:" },
            { "C:///", "C:" },
            { "C:/asdf", "C:" },
            { "C:/asdf/", "C:"},
            { "C:/asdf//", "C:"},
            { "C:/asdf///", "C:"},
            { "C:/foo.gig", "C:"},
        };
        for (auto ex : examples) {
            const std::string in  = ex.first;
            const std::string out = parentPath(in);
            const std::string expected = ex.second;
            if (out != expected) iErrors++;
            printf("parentPath('%s') => '%s' [%s]\n",
                   in.c_str(), out.c_str(),
                   ((out == expected) ? "ok" : "WRONG")
            );
        }
    }

    // test cases for function lastPathComponent()
    {
        // (a) input string, (b) expected result string
        std::pair<std::string, std::string> examples[] = {
            { "", "" },
            { "/", "" },
            { "//", "" },
            { "///", "" },
            { "/foo/bla", "bla" },
            { "/foo/bla/", "" },
            { "/foo/bla//", "" },
            { "/foo/bla///", "" },
            { "/foo", "foo" },
            { "/foo/", "" },
            { "/foo//", "" },
            { "/foo///", "" },
            { "/foo/asdf.gig", "asdf.gig" },
            { "foo", "foo" },
            { "asdf.gig", "asdf.gig" },
            { "C:", "" },
            { "C:/", "" },
            { "C://", "" },
            { "C:///", "" },
            { "C:/asdf", "asdf" },
            { "C:/asdf/", ""},
            { "C:/asdf//", ""},
            { "C:/asdf///", ""},
            { "C:/foo.gig", "foo.gig"},
        };
        for (auto ex : examples) {
            const std::string in  = ex.first;
            const std::string out = lastPathComponent(in);
            const std::string expected = ex.second;
            if (out != expected) iErrors++;
            printf("lastPathComponent('%s') => '%s' [%s]\n",
                   in.c_str(), out.c_str(),
                   ((out == expected) ? "ok" : "WRONG")
            );
        }
    }

    // test cases for function pathWithoutExtension()
    {
        // (a) input string, (b) expected result string
        std::pair<std::string, std::string> examples[] = {
            { "", "" },
            { "/foo/bla", "/foo/bla" },
            { "/foo", "/foo" },
            { "/foo/asdf.gig", "/foo/asdf" },
            { "/foo/asdf.gigx", "/foo/asdf" },
            { "foo", "foo" },
            { "asdf.gig", "asdf" },
            { "asdf.blabla", "asdf" },
            { "C:/foo.gig", "C:/foo"},
            { "C:/foo.blabla", "C:/foo"},
        };
        for (auto ex : examples) {
            const std::string in  = ex.first;
            const std::string out = pathWithoutExtension(in);
            const std::string expected = ex.second;
            if (out != expected) iErrors++;
            printf("pathWithoutExtension('%s') => '%s' [%s]\n",
                   in.c_str(), out.c_str(),
                   ((out == expected) ? "ok" : "WRONG")
            );
        }
    }

    // test cases for function extensionOfPath()
    {
        // (a) input string, (b) expected result string
        std::pair<std::string, std::string> examples[] = {
            { "", "" },
            { "/foo/bla", "" },
            { "/foo", "" },
            { "/foo/asdf.gig", "gig" },
            { "/foo/asdf.gigx", "gigx" },
            { "foo", "" },
            { "asdf.gig", "gig" },
            { "asdf.blabla", "blabla" },
            { "C:/foo.gig", "gig"},
            { "C:/foo.blabla", "blabla"},
        };
        for (auto ex : examples) {
            const std::string in  = ex.first;
            const std::string out = extensionOfPath(in);
            const std::string expected = ex.second;
            if (out != expected) iErrors++;
            printf("extensionOfPath('%s') => '%s' [%s]\n",
                   in.c_str(), out.c_str(),
                   ((out == expected) ? "ok" : "WRONG")
            );
        }
    }

    printf("\n[There were %d errors]\n", iErrors);
}
1	schoenebeck	3483	#include <stdlib.h>
2			#include <iostream>
3			#include <stdio.h>
4			#include <string>
5			#include <string.h>
6			#include <map>
7
8			// before including helper.h, pretend to be Windows to enable the drive (c:\) handling routines ...
9			#define _WIN32
10			// ... but at the same time force forward slash as our path separator for our tests
11			#define NATIVE_PATH_SEPARATOR '/'
12
13			#include "../helper.h"
14
15			int main() {
16			int iErrors = 0;
17
18			// test cases for function strip2ndFromEndOf1st()
19			{
20			// (a) input string, (b) expected result string
21			std::pair<std::string, std::string> examples[] = {
22			{ "", "" },
23			{ "/", "" },
24			{ "//", "" },
25			{ "///", "" },
26			{ "/foo/bla", "/foo/bla" },
27			{ "/foo/bla/", "/foo/bla" },
28			{ "/foo/bla//", "/foo/bla" },
29			{ "/foo/bla///", "/foo/bla" },
30			{ "/foo", "/foo" },
31			{ "/foo/", "/foo" },
32			{ "/foo//", "/foo" },
33			{ "/foo///", "/foo" },
34			{ "/foo/asdf.gig", "/foo/asdf.gig" },
35			{ "foo", "foo" },
36			{ "asdf.gig", "asdf.gig" },
37			{ "C:/", "C:" },
38			{ "C://", "C:" },
39			{ "C:", "C:" },
40			{ "C:/asdf", "C:/asdf" },
41			{ "C:/asdf/", "C:/asdf"},
42			{ "C:/asdf//", "C:/asdf"},
43			{ "C:/asdf///", "C:/asdf"},
44			};
45			for (auto ex : examples) {
46			const std::string in = ex.first;
47			const std::string out = strip2ndFromEndOf1st(in, '/');
48			const std::string expected = ex.second;
49			if (out != expected) iErrors++;
50			printf("strip2ndFromEndOf1st('%s', '/') => '%s' [%s]\n",
51			in.c_str(), out.c_str(),
52			((out == expected) ? "ok" : "WRONG")
53			);
54			}
55			}
56
57			// test cases for function parentPath()
58			{
59			// (a) input string, (b) expected result string
60			std::pair<std::string, std::string> examples[] = {
61			{ "", "" },
62			{ "/", "/" },
63			{ "//", "/" },
64			{ "///", "/" },
65			{ "/foo/bla", "/foo" },
66			{ "/foo/bla/", "/foo" },
67			{ "/foo/bla//", "/foo" },
68			{ "/foo/bla///", "/foo" },
69			{ "/foo", "/" },
70			{ "/foo/", "/" },
71			{ "/foo//", "/" },
72			{ "/foo///", "/" },
73			{ "/foo/asdf.gig", "/foo" },
74			{ "foo", "" },
75			{ "asdf.gig", "" },
76			{ "C:", "C:" },
77			{ "C:/", "C:" },
78			{ "C://", "C:" },
79			{ "C:///", "C:" },
80			{ "C:/asdf", "C:" },
81			{ "C:/asdf/", "C:"},
82			{ "C:/asdf//", "C:"},
83			{ "C:/asdf///", "C:"},
84			{ "C:/foo.gig", "C:"},
85			};
86			for (auto ex : examples) {
87			const std::string in = ex.first;
88			const std::string out = parentPath(in);
89			const std::string expected = ex.second;
90			if (out != expected) iErrors++;
91			printf("parentPath('%s') => '%s' [%s]\n",
92			in.c_str(), out.c_str(),
93			((out == expected) ? "ok" : "WRONG")
94			);
95			}
96			}
97
98			// test cases for function lastPathComponent()
99			{
100			// (a) input string, (b) expected result string
101			std::pair<std::string, std::string> examples[] = {
102			{ "", "" },
103			{ "/", "" },
104			{ "//", "" },
105			{ "///", "" },
106			{ "/foo/bla", "bla" },
107			{ "/foo/bla/", "" },
108			{ "/foo/bla//", "" },
109			{ "/foo/bla///", "" },
110			{ "/foo", "foo" },
111			{ "/foo/", "" },
112			{ "/foo//", "" },
113			{ "/foo///", "" },
114			{ "/foo/asdf.gig", "asdf.gig" },
115			{ "foo", "foo" },
116			{ "asdf.gig", "asdf.gig" },
117			{ "C:", "" },
118			{ "C:/", "" },
119			{ "C://", "" },
120			{ "C:///", "" },
121			{ "C:/asdf", "asdf" },
122			{ "C:/asdf/", ""},
123			{ "C:/asdf//", ""},
124			{ "C:/asdf///", ""},
125			{ "C:/foo.gig", "foo.gig"},
126			};
127			for (auto ex : examples) {
128			const std::string in = ex.first;
129			const std::string out = lastPathComponent(in);
130			const std::string expected = ex.second;
131			if (out != expected) iErrors++;
132			printf("lastPathComponent('%s') => '%s' [%s]\n",
133			in.c_str(), out.c_str(),
134			((out == expected) ? "ok" : "WRONG")
135			);
136			}
137			}
138
139			// test cases for function pathWithoutExtension()
140			{
141			// (a) input string, (b) expected result string
142			std::pair<std::string, std::string> examples[] = {
143			{ "", "" },
144			{ "/foo/bla", "/foo/bla" },
145			{ "/foo", "/foo" },
146			{ "/foo/asdf.gig", "/foo/asdf" },
147			{ "/foo/asdf.gigx", "/foo/asdf" },
148			{ "foo", "foo" },
149			{ "asdf.gig", "asdf" },
150			{ "asdf.blabla", "asdf" },
151			{ "C:/foo.gig", "C:/foo"},
152			{ "C:/foo.blabla", "C:/foo"},
153			};
154			for (auto ex : examples) {
155			const std::string in = ex.first;
156			const std::string out = pathWithoutExtension(in);
157			const std::string expected = ex.second;
158			if (out != expected) iErrors++;
159			printf("pathWithoutExtension('%s') => '%s' [%s]\n",
160			in.c_str(), out.c_str(),
161			((out == expected) ? "ok" : "WRONG")
162			);
163			}
164			}
165
166			// test cases for function extensionOfPath()
167			{
168			// (a) input string, (b) expected result string
169			std::pair<std::string, std::string> examples[] = {
170			{ "", "" },
171			{ "/foo/bla", "" },
172			{ "/foo", "" },
173			{ "/foo/asdf.gig", "gig" },
174			{ "/foo/asdf.gigx", "gigx" },
175			{ "foo", "" },
176			{ "asdf.gig", "gig" },
177			{ "asdf.blabla", "blabla" },
178			{ "C:/foo.gig", "gig"},
179			{ "C:/foo.blabla", "blabla"},
180			};
181			for (auto ex : examples) {
182			const std::string in = ex.first;
183			const std::string out = extensionOfPath(in);
184			const std::string expected = ex.second;
185			if (out != expected) iErrors++;
186			printf("extensionOfPath('%s') => '%s' [%s]\n",
187			in.c_str(), out.c_str(),
188			((out == expected) ? "ok" : "WRONG")
189			);
190			}
191			}
192
193			printf("\n[There were %d errors]\n", iErrors);
194			}