} else if (labelBytesLeft > publicSuffixBytesLeft) {
            low = mid + end + 1
          } else {
            // Found a match.
            match = String(this, mid, publicSuffixLength)
            break
          }
        }
      }
      return match
    }
  }

    assertTrue(toTest, toTest.matches(".*\\{field1\\=Hello\\}"));
  }

  public void testToStringLenient_oneIntegerField() {
    String toTest =
        MoreObjects.toStringHelper(new TestClass()).add("field1", Integer.valueOf(42)).toString();
    assertTrue(toTest, toTest.matches(".*\\{field1\\=42\\}"));
  }

  public void testToStringLenient_nullInteger() {

import javassist.CtClass
import javassist.CtField

/**
 * Matches Kotlin <code>internal</code> members.
 */
class KotlinInternalFilter implements ClassFilter, FieldFilter, BehaviorFilter {

    @Override
    boolean matches(CtClass ctClass) {
        return KotlinMetadataQueries.INSTANCE.isKotlinInternal(ctClass)
    }

    @Override
    boolean matches(CtField ctField) {

 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.matches
import org.junit.jupiter.api.Test

class OkHttpTest {
  @Test
  fun testVersion() {
    assertThat(OkHttp.VERSION).matches(Regex("[0-9]+\\.[0-9]+\\.[0-9]+(-.+)?"))
  }

			// standard metadata headers
			// specified in the filter
			var match bool
			for k, v := range obj.UserDefined {
				if !stringsHasPrefixFold(k, "x-amz-meta-") && !isStandardHeader(k) {
					continue
				}
				// We only need to match x-amz-meta or standardHeaders
				if kv.Match(BatchJobKV{Key: k, Value: v}) {
					match = true
				}
			}
			if !match {
				return false

	match := r.FindStringSubmatch(str)
	if match == nil {
		return nil
	}
	subMatchMap := make(map[string]string)
	for i, name := range r.SubexpNames() {
		if i != 0 {
			subMatchMap[name] = match[i]
		}
	}
	return subMatchMap
}

func isValidCGroupPathMatches(matches map[string]string) bool {
	if matches == nil {
		return false
	}

        classes.computeIfAbsent(className) {
            val outputClassName = if (unshadedPackages.matches(className)) className else shadowPackagePrefix + className
            ClassDetails(outputClassName).also { classDetails ->
                if (keepPackages.matches(className) && !ignorePackages.matches(className)) {
                    entryPoints.add(classDetails)
                }
            }
        }

        boolean matched = false;
        for (Iterator<String> i = patterns.iterator(); i.hasNext() & !matched; ) {
            // TODO what about wildcards? Just specifying groups? versions?
            if (id.equals(i.next())) {
                matched = true;
            }
        }
        return matched;
    }

    public List<String> getPatterns() {

    assertThat(cookie!!.matches("http://example.com".toHttpUrl())).isTrue()
    assertThat(cookie.matches("http://www.example.com".toHttpUrl())).isFalse()
    assertThat(cookie.matches("http://square.com".toHttpUrl())).isFalse()
  }

  /** Ignore an optional leading `.` in the domain.  */
  @Test fun domainMatchesIgnoresLeadingDot() {
    val cookie = parse(url, "a=b; domain=.example.com")

	if len(newID) != len(id) {
		log.Fatalf("%s: build ID length mismatch %q vs %q", file, id, newID)
	}

	if len(matches) == 0 {
		return
	}

	f, err = os.OpenFile(file, os.O_RDWR, 0)
	if err != nil {
		log.Fatal(err)
	}
	if err := buildid.Rewrite(f, matches, newID); err != nil {
		log.Fatal(err)
	}
	if err := f.Close(); err != nil {
		log.Fatal(err)
	}