diff --git a/core/src/module/usModuleResourceContainer.cpp b/core/src/module/usModuleResourceContainer.cpp
index 087639e056..efc9237f6d 100644
--- a/core/src/module/usModuleResourceContainer.cpp
+++ b/core/src/module/usModuleResourceContainer.cpp
@@ -1,224 +1,229 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed 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 "usModuleResourceContainer_p.h"
 
 #include "usModuleInfo.h"
 #include "usModuleUtils_p.h"
 #include "usModuleResource.h"
 #include "usLog_p.h"
 
 #include "miniz.h"
 
 #include <set>
 #include <cstring>
 #include <climits>
 #include <cassert>
 
 US_BEGIN_NAMESPACE
 
 struct ModuleResourceContainerPrivate
 {
   ModuleResourceContainerPrivate(const ModuleInfo* moduleInfo)
     : m_ModuleInfo(moduleInfo)
     , m_IsValid(false)
     , m_ZipArchive()
   {}
 
   typedef std::pair<std::string, int> NameIndexPair;
 
   struct PairComp
   {
     bool operator()(const NameIndexPair& p1, const NameIndexPair& p2) const
     {
       return p1.first < p2.first;
     }
   };
 
   typedef std::set<NameIndexPair, PairComp> SetType;
 
   void InitSortedEntries()
   {
     if (m_SortedEntries.empty())
     {
       mz_uint numFiles = mz_zip_reader_get_num_files(&m_ZipArchive);
       for (mz_uint fileIndex = 0; fileIndex < numFiles; ++fileIndex)
       {
         char fileName[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE];
         mz_zip_reader_get_filename(&m_ZipArchive, fileIndex, fileName, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE);
         m_SortedEntries.insert(std::make_pair(std::string(fileName), fileIndex));
       }
     }
   }
 
   const ModuleInfo* m_ModuleInfo;
   bool m_IsValid;
 
   mz_zip_archive m_ZipArchive;
 
   std::set<NameIndexPair, PairComp> m_SortedEntries;
 };
 
 ModuleResourceContainer::ModuleResourceContainer(const ModuleInfo* moduleInfo)
   : d(new ModuleResourceContainerPrivate(moduleInfo))
 {
   if (mz_zip_reader_init_file(&d->m_ZipArchive, moduleInfo->location.c_str(), 0))
   {
     d->m_IsValid = true;
   }
   else
   {
     US_DEBUG << "Could not init zip archive for module " << moduleInfo->name;
   }
 }
 
 ModuleResourceContainer::~ModuleResourceContainer()
 {
   if (IsValid())
   {
     mz_zip_reader_end(&d->m_ZipArchive);
   }
   delete d;
 }
 
 bool ModuleResourceContainer::IsValid() const
 {
   return d->m_IsValid;
 }
 
 bool ModuleResourceContainer::GetStat(ModuleResourceContainer::Stat& stat) const
 {
   if (IsValid())
   {
     int fileIndex = mz_zip_reader_locate_file(&d->m_ZipArchive, stat.filePath.c_str(), NULL, 0);
     if (fileIndex >= 0)
     {
       return GetStat(fileIndex, stat);
     }
   }
   return false;
 }
 
 bool ModuleResourceContainer::GetStat(int index, ModuleResourceContainer::Stat& stat) const
 {
   if (IsValid())
   {
     if (index >= 0)
     {
       mz_zip_archive_file_stat zipStat;
       if (!mz_zip_reader_file_stat(&d->m_ZipArchive, index, &zipStat))
       {
         return false;
       }
       stat.index = index;
       stat.filePath = zipStat.m_filename;
       stat.isDir = mz_zip_reader_is_file_a_directory(&d->m_ZipArchive, index) ? true : false;
       stat.modifiedTime = zipStat.m_time;
       // This will limit the size info from uint64 to uint32 on 32-bit
       // architectures. We don't care because we assume resources > 2GB
       // don't make sense to be embedded in a module anyway.
       assert(zipStat.m_comp_size < INT_MAX);
       assert(zipStat.m_uncomp_size < INT_MAX);
       stat.uncompressedSize = static_cast<int>(zipStat.m_uncomp_size);
       return true;
     }
   }
   return false;
 }
 
 void* ModuleResourceContainer::GetData(int index) const
 {
   return mz_zip_reader_extract_to_heap(&d->m_ZipArchive, index, NULL, 0);
 }
 
 const ModuleInfo*ModuleResourceContainer::GetModuleInfo() const
 {
   return d->m_ModuleInfo;
 }
 
 void ModuleResourceContainer::GetChildren(const std::string& resourcePath, bool relativePaths,
                                           std::vector<std::string>& names, std::vector<uint32_t>& indices) const
 {
   d->InitSortedEntries();
 
   ModuleResourceContainerPrivate::SetType::const_iterator iter =
       d->m_SortedEntries.find(std::make_pair(resourcePath, 0));
+  if (iter == d->m_SortedEntries.end())
+  {
+    return;
+  }
+
   for (++iter; iter != d->m_SortedEntries.end(); ++iter)
   {
     if (resourcePath.size() > iter->first.size()) break;
     if (iter->first.compare(0, resourcePath.size(), resourcePath) == 0)
     {
       std::size_t pos = iter->first.find_first_of('/', resourcePath.size());
       if (pos == std::string::npos || pos == iter->first.size()-1)
       {
         if (relativePaths)
         {
           names.push_back(iter->first.substr(resourcePath.size()));
         }
         else
         {
           names.push_back(iter->first);
         }
         indices.push_back(iter->second);
       }
     }
   }
 }
 
 void ModuleResourceContainer::FindNodes(const std::string& path, const std::string& filePattern,
                                         bool recurse, std::vector<ModuleResource>& resources) const
 {
   std::vector<std::string> names;
   std::vector<uint32_t> indices;
 
   this->GetChildren(path, true, names, indices);
 
   for(std::size_t i = 0, s = names.size(); i < s; ++i)
   {
     if (*names[i].rbegin() == '/' && recurse)
     {
       this->FindNodes(path + names[i], filePattern, recurse, resources);
     }
     if (this->Matches(names[i], filePattern))
     {
       resources.push_back(ModuleResource(indices[i], *this));
     }
   }
 }
 
 bool ModuleResourceContainer::Matches(const std::string& name, const std::string& filePattern) const
 {
   // short-cut
   if (filePattern == "*") return true;
 
   std::stringstream ss(filePattern);
   std::string tok;
   std::size_t pos = 0;
   while(std::getline(ss, tok, '*'))
   {
     std::size_t index = name.find(tok, pos);
     if (index == std::string::npos) return false;
     pos = index + tok.size();
   }
   return true;
 }
 
 US_END_NAMESPACE
diff --git a/core/test/usModuleResourceTest.cpp b/core/test/usModuleResourceTest.cpp
index 12daaa523c..d6a7a94c67 100644
--- a/core/test/usModuleResourceTest.cpp
+++ b/core/test/usModuleResourceTest.cpp
@@ -1,450 +1,452 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed 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 <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModuleRegistry.h>
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <usSharedLibrary.h>
 
 #include <usTestingConfig.h>
 
 #include "usTestingMacros.h"
 
 #include <cassert>
 
 #include <set>
 
 US_USE_NAMESPACE
 
 namespace {
 
   // Please confirm that a character count differing from the following targets is not due to
   // a misconfiguration of your versioning software (Correct line endings for your system)
   // See issue #18 ( https://github.com/saschazelzer/CppMicroServices/issues/18 )
 void checkResourceInfo(const ModuleResource& res, const std::string& path,
                        const std::string& baseName,
                        const std::string& completeBaseName, const std::string& suffix,
                        const std::string& completeSuffix,
                        int size, bool children = false)
 {
   US_TEST_CONDITION_REQUIRED(res.IsValid(), "Valid resource")
   US_TEST_CONDITION(res.GetBaseName() == baseName, "GetBaseName()")
   US_TEST_CONDITION(res.GetChildren().empty() == !children, "No children")
   US_TEST_CONDITION(res.GetCompleteBaseName() == completeBaseName, "GetCompleteBaseName()")
   US_TEST_CONDITION(res.GetName() == completeBaseName + "." + suffix, "GetName()")
   US_TEST_CONDITION(res.GetResourcePath() == path + completeBaseName + "." + suffix, "GetResourcePath()")
   US_TEST_CONDITION(res.GetPath() == path, "GetPath()")
   US_TEST_CONDITION(res.GetSize() == size, "Data size")
   US_TEST_CONDITION(res.GetSuffix() == suffix, "Suffix")
   US_TEST_CONDITION(res.GetCompleteSuffix() == completeSuffix, "Complete suffix")
 }
 
 void testTextResource(Module* module)
 {
   ModuleResource res = module->GetResource("foo.txt");
 #ifdef US_PLATFORM_WINDOWS
   checkResourceInfo(res, "/", "foo", "foo", "txt", "txt", 16, false);
   const std::streampos ssize(13);
   const std::string fileData = "foo and\nbar\n\n";
 #else
   checkResourceInfo(res, "/", "foo", "foo", "txt", "txt", 13, false);
   const std::streampos ssize(12);
   const std::string fileData = "foo and\nbar\n";
 #endif
 
   ModuleResourceStream rs(res);
 
   rs.seekg(0, std::ios::end);
   US_TEST_CONDITION(rs.tellg() == ssize, "Stream content length");
   rs.seekg(0, std::ios::beg);
 
   std::string content;
   content.reserve(res.GetSize());
   char buffer[1024];
   while (rs.read(buffer, sizeof(buffer)))
   {
     content.append(buffer, sizeof(buffer));
   }
   content.append(buffer, static_cast<std::size_t>(rs.gcount()));
 
   US_TEST_CONDITION(rs.eof(), "EOF check");
   US_TEST_CONDITION(content == fileData, "Resource content");
 
   rs.clear();
   rs.seekg(0);
 
   US_TEST_CONDITION_REQUIRED(rs.tellg() == std::streampos(0), "Move to start")
   US_TEST_CONDITION_REQUIRED(rs.good(), "Start re-reading");
 
   std::vector<std::string> lines;
   std::string line;
   while (std::getline(rs, line))
   {
     lines.push_back(line);
   }
   US_TEST_CONDITION_REQUIRED(lines.size() > 1, "Number of lines")
   US_TEST_CONDITION(lines[0] == "foo and", "Check first line")
   US_TEST_CONDITION(lines[1] == "bar", "Check second line")
 }
 
 void testTextResourceAsBinary(Module* module)
 {
   ModuleResource res = module->GetResource("foo.txt");
 
 #ifdef US_PLATFORM_WINDOWS
   checkResourceInfo(res, "/", "foo", "foo", "txt", "txt", 16, false);
   const std::streampos ssize(16);
   const std::string fileData = "foo and\r\nbar\r\n\r\n";
 #else
   checkResourceInfo(res, "/", "foo", "foo", "txt", "txt", 13, false);
   const std::streampos ssize(13);
   const std::string fileData = "foo and\nbar\n\n";
 #endif
 
 
   ModuleResourceStream rs(res, std::ios_base::binary);
 
   rs.seekg(0, std::ios::end);
   US_TEST_CONDITION(rs.tellg() == ssize, "Stream content length");
   rs.seekg(0, std::ios::beg);
 
   std::string content;
   content.reserve(res.GetSize());
   char buffer[1024];
   while (rs.read(buffer, sizeof(buffer)))
   {
     content.append(buffer, sizeof(buffer));
   }
   content.append(buffer, static_cast<std::size_t>(rs.gcount()));
 
   US_TEST_CONDITION(rs.eof(), "EOF check");
   US_TEST_CONDITION(content == fileData, "Resource content");
 }
 
 void testInvalidResource(Module* module)
 {
   ModuleResource res = module->GetResource("invalid");
   US_TEST_CONDITION_REQUIRED(res.IsValid() == false, "Check invalid resource")
   US_TEST_CONDITION(res.GetName().empty(), "Check empty name")
   US_TEST_CONDITION(res.GetPath().empty(), "Check empty path")
   US_TEST_CONDITION(res.GetResourcePath().empty(), "Check empty resource path")
   US_TEST_CONDITION(res.GetBaseName().empty(), "Check empty base name")
   US_TEST_CONDITION(res.GetCompleteBaseName().empty(), "Check empty complete base name")
   US_TEST_CONDITION(res.GetSuffix().empty(), "Check empty suffix")
 
   US_TEST_CONDITION(res.GetChildren().empty(), "Check empty children")
   US_TEST_CONDITION(res.GetSize() == 0, "Check zero size")
 
   ModuleResourceStream rs(res);
   US_TEST_CONDITION(rs.good() == true, "Check invalid resource stream")
   rs.ignore();
   US_TEST_CONDITION(rs.good() == false, "Check invalid resource stream")
   US_TEST_CONDITION(rs.eof() == true, "Check invalid resource stream")
 }
 
 void testSpecialCharacters(Module* module)
 {
   ModuleResource res = module->GetResource("special_chars.dummy.txt");
 #ifdef US_PLATFORM_WINDOWS
   checkResourceInfo(res, "/", "special_chars", "special_chars.dummy", "txt", "dummy.txt", 56, false);
   const std::streampos ssize(54);
   const std::string fileData = "German Füße (feet)\nFrench garçon de café (waiter)\n";
 #else
   checkResourceInfo(res, "/", "special_chars", "special_chars.dummy", "txt", "dummy.txt", 54, false);
   const std::streampos ssize(53);
   const std::string fileData = "German Füße (feet)\nFrench garçon de café (waiter)";
 #endif
 
   ModuleResourceStream rs(res);
 
   rs.seekg(0, std::ios_base::end);
   US_TEST_CONDITION(rs.tellg() == ssize, "Stream content length");
   rs.seekg(0, std::ios_base::beg);
 
   std::string content;
   content.reserve(res.GetSize());
   char buffer[1024];
   while (rs.read(buffer, sizeof(buffer)))
   {
     content.append(buffer, sizeof(buffer));
   }
   content.append(buffer, static_cast<std::size_t>(rs.gcount()));
 
   US_TEST_CONDITION(rs.eof(), "EOF check");
   US_TEST_CONDITION(content == fileData, "Resource content");
 }
 
 void testBinaryResource(Module* module)
 {
   ModuleResource res = module->GetResource("/icons/cppmicroservices.png");
   checkResourceInfo(res, "/icons/", "cppmicroservices", "cppmicroservices", "png", "png", 2424, false);
 
   ModuleResourceStream rs(res, std::ios_base::binary);
   rs.seekg(0, std::ios_base::end);
   std::streampos resLength = rs.tellg();
   rs.seekg(0);
 
   std::ifstream png(US_CORE_SOURCE_DIR "/test/modules/libRWithResources/resources/icons/cppmicroservices.png",
                     std::ifstream::in | std::ifstream::binary);
 
   US_TEST_CONDITION_REQUIRED(png.is_open(), "Open reference file")
 
   png.seekg(0, std::ios_base::end);
   std::streampos pngLength = png.tellg();
   png.seekg(0);
   US_TEST_CONDITION(res.GetSize() == resLength, "Check resource size")
   US_TEST_CONDITION_REQUIRED(resLength == pngLength, "Compare sizes")
 
   char c1 = 0;
   char c2 = 0;
   bool isEqual = true;
   int count = 0;
   while (png.get(c1) && rs.get(c2))
   {
     ++count;
     if (c1 != c2)
     {
       isEqual = false;
       break;
     }
   }
 
   US_TEST_CONDITION_REQUIRED(count == pngLength, "Check if everything was read");
   US_TEST_CONDITION_REQUIRED(isEqual, "Equal binary contents");
   US_TEST_CONDITION(png.eof(), "EOF check");
 }
 
 void testCompressedResource(Module* module)
 {
   ModuleResource res = module->GetResource("/icons/compressable.bmp");
   checkResourceInfo(res, "/icons/", "compressable", "compressable", "bmp", "bmp", 300122, false);
 
   ModuleResourceStream rs(res, std::ios_base::binary);
   rs.seekg(0, std::ios_base::end);
   std::streampos resLength = rs.tellg();
   rs.seekg(0);
 
   std::ifstream bmp(US_CORE_SOURCE_DIR "/test/modules/libRWithResources/resources/icons/compressable.bmp",
                     std::ifstream::in | std::ifstream::binary);
 
   US_TEST_CONDITION_REQUIRED(bmp.is_open(), "Open reference file")
 
   bmp.seekg(0, std::ios_base::end);
   std::streampos bmpLength = bmp.tellg();
   bmp.seekg(0);
   US_TEST_CONDITION(300122 == resLength, "Check resource size")
   US_TEST_CONDITION_REQUIRED(resLength == bmpLength, "Compare sizes")
 
   char c1 = 0;
   char c2 = 0;
   bool isEqual = true;
   int count = 0;
   while (bmp.get(c1) && rs.get(c2))
   {
     ++count;
     if (c1 != c2)
     {
       isEqual = false;
       break;
     }
   }
 
   US_TEST_CONDITION_REQUIRED(count == bmpLength, "Check if everything was read");
   US_TEST_CONDITION_REQUIRED(isEqual, "Equal binary contents");
   US_TEST_CONDITION(bmp.eof(), "EOF check");
 }
 
 struct ResourceComparator {
   bool operator()(const ModuleResource& mr1, const ModuleResource& mr2) const
   {
     return mr1 < mr2;
   }
 };
 
 void testResourceTree(Module* module)
 {
   ModuleResource res = module->GetResource("");
   US_TEST_CONDITION(res.GetResourcePath() == "/", "Check root file path")
   US_TEST_CONDITION(res.IsDir() == true, "Check type")
 
   std::vector<std::string> children = res.GetChildren();
   std::sort(children.begin(), children.end());
   US_TEST_CONDITION_REQUIRED(children.size() == 4, "Check child count")
   US_TEST_CONDITION(children[0] == "foo.txt", "Check child name")
   US_TEST_CONDITION(children[1] == "icons/", "Check child name")
   US_TEST_CONDITION(children[2] == "special_chars.dummy.txt", "Check child name")
   US_TEST_CONDITION(children[3] == "test.xml", "Check child name")
 
+  US_TEST_CONDITION(module->FindResources("!$noexist=?", std::string(), "true").empty(), "Check not existant path");
+
 
   ModuleResource readme = module->GetResource("/icons/readme.txt");
   US_TEST_CONDITION(readme.IsFile() && readme.GetChildren().empty(), "Check file resource")
 
   ModuleResource icons = module->GetResource("icons/");
   US_TEST_CONDITION(icons.IsDir() && !icons.IsFile() && !icons.GetChildren().empty(), "Check directory resource")
 
   children = icons.GetChildren();
   US_TEST_CONDITION_REQUIRED(children.size() == 3, "Check icons child count")
   std::sort(children.begin(), children.end());
   US_TEST_CONDITION(children[0] == "compressable.bmp", "Check child name")
   US_TEST_CONDITION(children[1] == "cppmicroservices.png", "Check child name")
   US_TEST_CONDITION(children[2] == "readme.txt", "Check child name")
 
   ResourceComparator resourceComparator;
 
   // find all .txt files
   std::vector<ModuleResource> nodes = module->FindResources("", "*.txt", false);
   std::sort(nodes.begin(), nodes.end(), resourceComparator);
   US_TEST_CONDITION_REQUIRED(nodes.size() == 2, "Found child count")
   US_TEST_CONDITION(nodes[0].GetResourcePath() == "/foo.txt", "Check child name")
   US_TEST_CONDITION(nodes[1].GetResourcePath() == "/special_chars.dummy.txt", "Check child name")
 
   nodes = module->FindResources("", "*.txt", true);
   std::sort(nodes.begin(), nodes.end(), resourceComparator);
   US_TEST_CONDITION_REQUIRED(nodes.size() == 3, "Found child count")
   US_TEST_CONDITION(nodes[0].GetResourcePath() == "/foo.txt", "Check child name")
   US_TEST_CONDITION(nodes[1].GetResourcePath() == "/icons/readme.txt", "Check child name")
   US_TEST_CONDITION(nodes[2].GetResourcePath() == "/special_chars.dummy.txt", "Check child name")
 
   // find all resources
   nodes = module->FindResources("", "", true);
   US_TEST_CONDITION(nodes.size() == 7, "Total resource number")
   nodes = module->FindResources("", "**", true);
   US_TEST_CONDITION(nodes.size() == 7, "Total resource number")
 
 
   // test pattern matching
   nodes.clear();
   nodes = module->FindResources("/icons", "*micro*.png", false);
   US_TEST_CONDITION(nodes.size() == 1 && nodes[0].GetResourcePath() == "/icons/cppmicroservices.png", "Check file pattern matches")
 
   nodes.clear();
   nodes = module->FindResources("", "*.txt", true);
   US_TEST_CONDITION(nodes.size() == 3, "Check recursive pattern matches")
 }
 
 void testResourceOperators(Module* module)
 {
   ModuleResource invalid = module->GetResource("invalid");
   ModuleResource foo = module->GetResource("foo.txt");
   US_TEST_CONDITION_REQUIRED(foo.IsValid() && foo, "Check valid resource")
   ModuleResource foo2(foo);
   US_TEST_CONDITION(foo == foo, "Check equality operator")
   US_TEST_CONDITION(foo == foo2, "Check copy constructor and equality operator")
   US_TEST_CONDITION(foo != invalid, "Check inequality with invalid resource")
 
   ModuleResource xml = module->GetResource("/test.xml");
   US_TEST_CONDITION_REQUIRED(xml.IsValid() && xml, "Check valid resource")
   US_TEST_CONDITION(foo != xml, "Check inequality")
   US_TEST_CONDITION(foo < xml, "Check operator<")
 
   // check operator< by using a set
   std::set<ModuleResource> resources;
   resources.insert(foo);
   resources.insert(foo);
   resources.insert(xml);
   US_TEST_CONDITION(resources.size() == 2, "Check operator< with set")
 
   // check hash function specialization
   US_UNORDERED_SET_TYPE<ModuleResource> resources2;
   resources2.insert(foo);
   resources2.insert(foo);
   resources2.insert(xml);
   US_TEST_CONDITION(resources2.size() == 2, "Check operator< with unordered set")
 
   // check operator<<
   std::ostringstream oss;
   oss << foo;
   US_TEST_CONDITION(oss.str() == foo.GetResourcePath(), "Check operator<<")
 }
 
 void testResourceFromExecutable(Module* module)
 {
   ModuleResource resource = module->GetResource("usTestResource.txt");
   US_TEST_CONDITION_REQUIRED(resource.IsValid(), "Check valid executable resource")
 
   std::string line;
   ModuleResourceStream rs(resource);
   std::getline(rs, line);
   US_TEST_CONDITION(line == "meant to be compiled into the test driver", "Check executable resource content")
 }
 
 } // end unnamed namespace
 
 
 int usModuleResourceTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("ModuleResourceTest");
 
   ModuleContext* mc = GetModuleContext();
   assert(mc);
 
 #ifdef US_BUILD_SHARED_LIBS
 
 #ifdef US_PLATFORM_WINDOWS
   const std::string LIB_PATH = US_RUNTIME_OUTPUT_DIRECTORY;
 #else
   const std::string LIB_PATH = US_LIBRARY_OUTPUT_DIRECTORY;
 #endif
   SharedLibrary libR(LIB_PATH, "TestModuleR");
 
   try
   {
     libR.Load();
   }
   catch (const std::exception& e)
   {
     US_TEST_FAILED_MSG(<< "Load module exception: " << e.what())
   }
 #endif
 
   Module* moduleR = ModuleRegistry::GetModule("TestModuleR");
   US_TEST_CONDITION_REQUIRED(moduleR != NULL, "Test for existing module TestModuleR")
 
   US_TEST_CONDITION(moduleR->GetName() == "TestModuleR", "Test module name")
 
   testInvalidResource(moduleR);
 
   testResourceFromExecutable(mc->GetModule());
 
   testResourceTree(moduleR);
 
   testResourceOperators(moduleR);
 
   testTextResource(moduleR);
   testTextResourceAsBinary(moduleR);
   testSpecialCharacters(moduleR);
 
   testBinaryResource(moduleR);
 
   testCompressedResource(moduleR);
 
   ModuleResource foo = moduleR->GetResource("foo.txt");
   US_TEST_CONDITION(foo.IsValid() == true, "Valid resource")
 #ifdef US_BUILD_SHARED_LIBS
   libR.Unload();
   US_TEST_CONDITION(foo.IsValid() == true, "Still valid resource")
 #endif
 
   US_TEST_END()
 }