// This filter has tags configured but this object
	// does not have any tag, skip this object
	if len(tagsMap) == 0 {
		return false
	}

	// Both filter and object have tags, find a match,
	// skip this object otherwise
	for k, cv := range f.cachedTags {
		v, ok := tagsMap[k]
		if ok && v == cv {
			return true
		}
	}

	return false

}

# Note: this is excluded on the full code base, since any submitted code must
# have passed Google's internal style guidelines.
@test "Check formatting for C++ files" {
    skip "clang-format doesn't match internal clang-format checker"
    echo "clang-format is recommended. Here are the suggested changes:"
    echo "============================="

                            List<LogNotificationEvent> drained = helper.drainAll();
                            totalDrained.addAndGet(drained.size());
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    doneLatch.countDown();
                }
            });
        }

,c=(parseInt(b,10)%97).toString()+c.slice(b.length);return parseInt(c,10)%97===1},d=function(a){a=a.toUpperCase(),a=a.replace(/\s+/g,"");var c=a.slice(0,2),d=0,e="";for(d=0;d<b.length;++d)if(b[d][0]===c){e=b[d][2];break}if(""===e)return!1;var f=e.match(/(.{3})/g).map(function(a){var b,c=a.slice(0,1),d=parseInt(a.slice(1),10);switch(c){case"A":b="0-9A-Za-z";break;case"B":b="0-9A-Z";break;case"C":b="A-Za-z";break;case"F":b="0-9";break;case"L":b="a-z";break;case"U":b="A-Z";break;case"W":b="0-9a-z"}...

        }
        val version = milestone.get()
        val parts = version.split(".")
        require(parts.size == 3 && parts[2].toIntOrNull()?.let { it != 0 } == true) {
            "Version '$version' is not a patch release. Expected format: x.y.z with z > 0."
        }
        val issues = getFixedIssues()
        require(!issues.isEmpty()) {
            "No fixed issues found for milestone ${milestone.get()}"
        }

     * some symbolic names meaningful to humans.
     */
    private static int decode(String userFriendly) {
      try {
        return Integer.decode(userFriendly);
      } catch (NumberFormatException ignored) {
        if (userFriendly.matches("(?i)(?:American|English|ASCII)")) {
          // 1-byte UTF-8 sequences - "American" ASCII text
          return 0x80;

        // Reset index to read back
        buf.reset();
        NdrShort decoded = new NdrShort(0); // placeholder value
        decoded.decode(buf);
        assertEquals(expected, decoded.value, "decoded value should match original after masking");
    }

    /**
     * Verify that encode writes the correct little-endian sequence
     * to the buffer and that alignment is respected.
     */
    @Test

    assert response.json() == {
        "detail": [
            {
                "type": "string_pattern_mismatch",
                "loc": ["body", "grant_type"],
                "msg": "String should match pattern '^password$'",
                "input": grant_type,
                "ctx": {"pattern": "^password$"},
            }
        ]
    }


def test_strict_login_correct_grant_type():

    assert response.json() == {
        "detail": [
            {
                "type": "string_pattern_mismatch",
                "loc": ["body", "grant_type"],
                "msg": "String should match pattern '^password$'",
                "input": grant_type,
                "ctx": {"pattern": "^password$"},
            }
        ]
    }


def test_strict_login_correct_correct_grant_type():

				OutputBytes:     len(resp),
				TimeToFirstByte: end.Sub(start),
			},
		},
	}
	// If the context contains a TraceParamsKey, add it to the trace path.
	v := ctx.Value(TraceParamsKey{})
	// Should match SingleHandler.Call checks.
	switch typed := v.(type) {
	case *MSS:
		trace.Path += typed.ToQuery()
	case map[string]string:
		m := MSS(typed)
		trace.Path += m.ToQuery()
	case *URLValues: