#include <exiv2/exiv2.hpp>
// File under test
#include <exiv2/futils.hpp>
// Auxiliary headers
#include <fstream>
#include <cstdio>
#include <cerrno>
#include <stdexcept>
#include "gtestwrapper.h"
using namespace Exiv2;
TEST(strError, returnSuccessAfterClosingFile)
{
// previous system calls can fail, but errno is not guaranteed to be reset
// by a successful system call
// -> reset errno so that a real failure is only detected here
errno = 0;
std::string tmpFile("tmp.dat");
std::ofstream auxFile(tmpFile.c_str());
auxFile.close();
#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW__) || defined(__MSYS__)
const char * expectedString = "No error (errno = 0)";
#elif defined(__APPLE__)
const char * expectedString = "Undefined error: 0 (errno = 0)";
#elif defined(__sun__)
const char * expectedString = "Error 0 (errno = 0)";
#elif defined(__FreeBSD__)
const char * expectedString = "No error: 0 (errno = 0)";
#elif defined(__NetBSD__)
const char * expectedString = "Undefined error: 0 (errno = 0)";
#else
const char * expectedString = "Success (errno = 0)";
#endif
std::remove(tmpFile.c_str());
ASSERT_STREQ(expectedString, strError().c_str());
}
TEST(strError, returnNoSuchFileOrDirectoryWhenTryingToOpenNonExistingFile)
{
std::ifstream auxFile("nonExistingFile");
ASSERT_STREQ("No such file or directory (errno = 2)", strError().c_str());
}
TEST(strError, doNotRecognizeUnknownError)
{
errno = 9999;
#if defined(__MINGW__) || defined(__MSYS__) || defined(__CYGWIN__)
const char * expectedString = "Unknown error 9999 (errno = 9999)";
#elif defined(_WIN32)
const char * expectedString = "Unknown error (errno = 9999)";
#elif defined(__APPLE__)
const char * expectedString = "Unknown error: 9999 (errno = 9999)";
#elif defined(__sun__)
const char * expectedString = "Unknown error (errno = 9999)";
#elif defined(__FreeBSD__)
const char * expectedString = "Unknown error: 9999 (errno = 9999)";
#elif defined(__NetBSD__)
const char * expectedString = "Unknown error: 9999 (errno = 9999)";
#else
const char * expectedString = "Unknown error 9999 (errno = 9999)";
#endif
ASSERT_STREQ(expectedString, strError().c_str());
}
TEST(getEnv, getsDefaultValueWhenExpectedEnvVariableDoesNotExist)
{
ASSERT_STREQ("/exiv2.php", getEnv(envHTTPPOST).c_str());
ASSERT_STREQ("40", getEnv(envTIMEOUT).c_str());
}
TEST(getEnv, getsProperValuesWhenExpectedEnvVariableExists)
{
const char * expectedValue = "test";
#ifdef _WIN32
ASSERT_EQ(0, _putenv_s("EXIV2_HTTP_POST", expectedValue));
#else
ASSERT_EQ(0, setenv("EXIV2_HTTP_POST", expectedValue, 1));
#endif
ASSERT_STREQ(expectedValue, getEnv(envHTTPPOST).c_str());
#ifndef _WIN32
ASSERT_EQ(0, unsetenv("EXIV2_HTTP_POST"));
#endif
}
TEST(getEnv, throwsWhenKeyDoesNotExist)
{
ASSERT_THROW(getEnv(static_cast<EnVar>(3)), std::out_of_range);
}
TEST(urlencode, encodesGivenUrl)
{
const std::string url = urlencode("http://www.geekhideout.com/urlcode.shtml");
ASSERT_STREQ("http%3a%2f%2fwww.geekhideout.com%2furlcode.shtml", url.c_str());
}
TEST(urlencode, encodesGivenUrlWithSpace)
{
const std::string url = urlencode("http://www.geekhideout.com/url code.shtml");
ASSERT_STREQ("http%3a%2f%2fwww.geekhideout.com%2furl+code.shtml", url.c_str());
}
TEST(urldecode, decodesGivenUrl)
{
const std::string expectedDecodedUrl ("http://www.geekhideout.com/urlcode.shtml");
const std::string url ("http%3a%2f%2fwww.geekhideout.com%2furlcode.shtml");
char * url3 = urldecode(url.c_str());
ASSERT_STREQ(expectedDecodedUrl.c_str(), url3);
delete [] url3;
}
TEST(urldecode, decodesGivenUrlInPlace)
{
const std::string expectedDecodedUrl ("http://www.geekhideout.com/urlcode.shtml");
std::string url ("http%3a%2f%2fwww.geekhideout.com%2furlcode.shtml");
urldecode(url);
ASSERT_STREQ(expectedDecodedUrl.c_str(), url.c_str());
}
TEST(base64encode, encodesValidString)
{
const std::string original ("This is a unit test");
const std::string expected ("VGhpcyBpcyBhIHVuaXQgdGVzdA==");
size_t encodeLength = ((original.size() + 2) / 3) * 4 + 1;
char * result = new char [encodeLength];
ASSERT_EQ(1, base64encode(original.c_str(), original.size(), result, encodeLength));
ASSERT_STREQ(expected.c_str(), result);
delete [] result;
}
TEST(base64encode, doesNotEncodeWithNotBigEnoughResultSize)
{
const std::string original ("This is a unit test");
size_t encodeLength = (original.size());
char * result = new char [encodeLength];
ASSERT_EQ(0, base64encode(original.c_str(), original.size(), result, encodeLength));
delete [] result;
}
TEST(base64decode, decodesValidString)
{
const std::string original ("VGhpcyBpcyBhIHVuaXQgdGVzdA==");
const std::string expected ("This is a unit test");
char * result = new char [original.size()];
ASSERT_EQ(static_cast<long>(expected.size()+1),
base64decode(original.c_str(), result, original.size()));
ASSERT_STREQ(expected.c_str(), result);
delete [] result;
}
TEST(AUri, parsesAndDecoreUrl)
{
const std::string url("http://www.geekhideout.com/urlcode.shtml");
Uri uri = Uri::Parse(url);
ASSERT_EQ("", uri.QueryString);
ASSERT_EQ("http", uri.Protocol);
ASSERT_EQ("www.geekhideout.com", uri.Host);
ASSERT_EQ("80", uri.Port);
ASSERT_EQ("/urlcode.shtml", uri.Path);
ASSERT_EQ("", uri.Username);
ASSERT_EQ("", uri.Password);
Uri::Decode(uri);
}
#if 0
//1122 This has been removed for v0.27.3
// On MinGW:
// path = C:\msys64\home\rmills\gnu\github\exiv2\buildserver\build\bin\unit_tests.exe
// expected = bin
// I don't know how this could work successfully on any platform!
TEST(getProcessPath, obtainPathOfUnitTestsExecutable)
{
#ifdef _WIN32
const std::string expectedName("bin");
#else
const std::string expectedName("bin");
#endif
const std::string path = getProcessPath();
FILE* f = fopen("/c//temp/test_futils.log","w");
fprintf(f,"path = %s\n",path.c_str() );
fprintf(f,"expected = %s\n",expectedName.c_str());
fclose(f);
ASSERT_FALSE(path.empty());
const size_t idxStart = path.size() - expectedName.size();
ASSERT_EQ(expectedName, path.substr(idxStart, expectedName.size()));
}
#endif