Implemented wildcard_match_any() and wildcard_match_all() with tests.

Author: end2endzone

src/bin2cpp/wildcard.cpp

@@ -140,4 +140,32 @@ namespace bin2cpp
     return match;
   }
 
+  bool wildcard_match_any(const std::string& value, const std::vector<std::string>& patterns)
+  {
+    bool result = false;
+    std::vector<std::string> captures;
+    for ( size_t i = 0; i < patterns.size(); i++ )
+    {
+      const std::string& pattern = patterns[i];
+      bool match = wildcard_match(value, pattern, captures);
+      if ( match )
+        return true;
+    }
+    return result;
+  }
+
+  bool wildcard_match_all(const std::string& value, const std::vector<std::string>& patterns)
+  {
+    bool result = true;
+    std::vector<std::string> captures;
+    for ( size_t i = 0; i < patterns.size(); i++ )
+    {
+      const std::string& pattern = patterns[i];
+      bool match = wildcard_match(value, pattern, captures);
+      if ( !match )
+        return false;
+    }
+    return result;
+  }
+
 }; //bin2cpp

src/bin2cpp/wildcard.h

@@ -42,7 +42,7 @@ namespace bin2cpp
   ///  -'[charlist]' matches any character in the provided set.
   ///  -'[a-z]', '[A-Z]', '[0-9]' match characters in respective ranges.
   ///  -'[a-zA-Z0-9]' matches any alphanumeric character.
-  ///< / remarks>
+  ///</remarks>
   ///<param name="value">The file path, value or string to match.</param>
   ///<param name="pattern">The pattern containing wildcards.</param>
   ///<param name="captures">The captured value of wildcard within the input value. The number of captures matches the number of wildcard in the pattern.</param>
@@ -60,7 +60,7 @@ namespace bin2cpp
   ///  -'[charlist]' matches any character in the provided set.
   ///  -'[a-z]', '[A-Z]', '[0-9]' match characters in respective ranges.
   ///  -'[a-zA-Z0-9]' matches any alphanumeric character.
-  ///< / remarks>
+  ///</remarks>
   ///<param name="value">The file path, value or string to match.</param>
   ///<param name="pattern">The pattern containing wildcards.</param>
   ///<returns>Returns true if the value matches the pattern, otherwise false.</returns>
@@ -70,6 +70,22 @@ namespace bin2cpp
     return wildcard_match(value, pattern, tmp_captures);
   }
 
+  ///<summary>
+  ///Checks if a given value matches at least one of the given patterns.
+  ///</summary>
+  ///<param name="value">The file path, value or string to match.</param>
+  ///<param name="patterns">The list of patterns containing wildcards.</param>
+  ///<returns>Returns true if the value matches the any pattern, otherwise false.</returns>
+  bool wildcard_match_any(const std::string& value, const std::vector<std::string>& patterns);
+
+  ///<summary>
+  ///Checks if a given value matches at of the given patterns.
+  ///</summary>
+  ///<param name="value">The file path, value or string to match.</param>
+  ///<param name="patterns">The list of patterns containing wildcards.</param>
+  ///<returns>Returns true if the value matches the any pattern, otherwise false.</returns>
+  bool wildcard_match_all(const std::string& value, const std::vector<std::string>& patterns);
+
 }; //bin2cpp
 
 #endif //BIN2CPP_COMMON_H

test/bin2cpp_unittest/TestWildcard.cpp

@@ -41,14 +41,14 @@ std::string to_boolean_str(bool value)
 
 TEST_F(TestWildcard, testBasicExamples)
 {
-  struct TESTVALUE
+  struct TEST_HELPER
   {
     const char* value;
     const char* pattern;
     bool expected_result;
     std::vector<std::string> expected_captures;
   };
-  static const TESTVALUE test_values[] = {
+  static const TEST_HELPER test_values[] = {
       // ============================== matches ==============================
       // ?
       {"a", "?",                                                      true, {"a"}},
@@ -102,13 +102,87 @@ TEST_F(TestWildcard, testBasicExamples)
 
   for ( size_t i = 0; i < num_test_values; i++ )
   {
-    const TESTVALUE& t = test_values[i];
+    const TEST_HELPER& t = test_values[i];
 
     std::vector<std::string> actual_captures;
     bool actual_result = bin2cpp::wildcard_match(t.value, t.pattern, actual_captures);
 
     ASSERT_EQ(actual_result, t.expected_result)     << "Test fail with test_values[" << i << "]. The match between value '" << t.value << "' and pattern '" << t.pattern << "' is supposed to return '" << to_boolean_str(t.expected_result) << "' but it actually retuned '" << to_boolean_str(actual_result) << "'.";
     ASSERT_EQ(actual_captures, t.expected_captures) << "Test fail with test_values[" << i << "]. The match between value '" << t.value << "' and pattern '" << t.pattern << "' is has returned '" << to_boolean_str(t.expected_result) << "' but the expected captures does not match.";
   }
+}
+
+TEST_F(TestWildcard, testWildcardMatchAny)
+{
+  const std::string path = "path/to/a/file.jpg";
+  std::vector<std::string> patterns;
+
+  {
+    // test for no matches
+    patterns.clear();
+    patterns.push_back("idonotmatch");
+    patterns.push_back("idonotmatcheither");
+
+    ASSERT_FALSE(bin2cpp::wildcard_match_any(path, patterns));
+  }
+
+  {
+    // test matches from first element
+    patterns.clear();
+    patterns.push_back("*.jpg");
+    patterns.push_back("idonotmatch");
+
+    ASSERT_TRUE(bin2cpp::wildcard_match_any(path, patterns));
+  }
+
+  {
+    // test matches from second element
+    patterns.clear();
+    patterns.push_back("idonotmatch");
+    patterns.push_back("*.jpg");
 
+    ASSERT_TRUE(bin2cpp::wildcard_match_any(path, patterns));
+  }
 }
+
+TEST_F(TestWildcard, testWildcardMatchAll)
+{
+  const std::string path = "path/to/a/file.jpg";
+  std::vector<std::string> patterns;
+
+  {
+    // test for no matches
+    patterns.clear();
+    patterns.push_back("idonotmatch");
+    patterns.push_back("idonotmatcheither");
+
+    ASSERT_FALSE(bin2cpp::wildcard_match_all(path, patterns));
+  }
+
+  {
+    // test matches from first element
+    patterns.clear();
+    patterns.push_back("*.jpg");
+    patterns.push_back("idonotmatch");
+
+    ASSERT_FALSE(bin2cpp::wildcard_match_all(path, patterns));
+  }
+
+  {
+    // test matches from second element
+    patterns.clear();
+    patterns.push_back("idonotmatch");
+    patterns.push_back("*.jpg");
+
+    ASSERT_FALSE(bin2cpp::wildcard_match_all(path, patterns));
+  }
+
+  {
+    // test matches from all elements
+    patterns.clear();
+    patterns.push_back("*/to/*");
+    patterns.push_back("*.jpg");
+
+    ASSERT_TRUE(bin2cpp::wildcard_match_all(path, patterns));
+  }
+}