convention: implementation("foo:bar:1.0"),
                buildConfiguration: "",
                expectedConfigurations: [
                    "implementation = ${externalDependency('foo', 'bar', '1.0')}"
                ]
            ],
            [
                testCase: "implementation has convention and api is set",
                convention: implementation("foo:bar:1.0"),

        groupSet("foo", "foz")             | module("bar")         | moduleIdSet("foo:bar", "foz:bar")
        groupSet("foo", "foz")             | moduleSet("bar", "baz")         | moduleIdSet("foo:bar", "foz:bar", "foo:baz", "foz:baz")
        allOf(group("foo"), group("foo2")) | module("bar")         | nothing()

	type T2 struct {
		a string
		b int
	}
	const size = 1024
	var (
		str1 = "foobar"
		str2 = "foobarz"

		a [size]T2
		c [size]T2
	)

	for i := 0; i < size; i++ {
		a[i].a = str1
		c[i].a = str1
	}
	c[len(c)-1].a = str2

	b.ResetTimer()
	for j := 0; j < b.N; j++ {
		_ = a == c
	}
}

const size = 16

type T1 struct {

							{
								Patch: &networking.EnvoyFilter_Patch{},
								Match: &networking.EnvoyFilter_EnvoyConfigObjectMatch{
									Proxy: &networking.EnvoyFilter_ProxyMatch{ProxyVersion: `foobaz`},
								},
							},
						},
					},
				},
			},
			updates: []config.Config{},
			deletes: []ConfigKey{},
		},
		{
			name:    "update one",
			creates: []config.Config{},

    @Test
    fun `#isLegalAccessorName rejects illegal Kotlin extension names`() {

        assert(isLegalAccessorName("foo_bar"))
        assert(isLegalAccessorName("foo-bar"))
        assert(isLegalAccessorName("foo bar"))
        assert(isLegalAccessorName("'foo'bar'"))
        assert(isLegalAccessorName("foo${'$'}${'$'}bar"))

        assertFalse(isLegalAccessorName("foo`bar"))

    def "allows setting forced modules"() {
        expect:
        strategy.forcedModules.empty

        when:
        strategy.force 'org.foo:bar:1.0', 'org.foo:baz:2.0'

        then:
        def versions = strategy.forcedModules as List
        versions.size() == 2

        versions[0].group == 'org.foo'
        versions[0].name == 'bar'

  }

  public void testFindClassesToTest_ignoreUnderscores() {
    assertThat(findClassesToTest(ImmutableList.of(Foo.class, Foo_Bar.class)))
        .containsExactly(Foo.class, Foo_Bar.class);
    sanityTests.ignoreClasses(AbstractPackageSanityTests.UNDERSCORE_IN_NAME);
    assertThat(findClassesToTest(ImmutableList.of(Foo.class, Foo_Bar.class)))
        .containsExactly(Foo.class);
  }

	blankHighPriority := NewReplacer("", "X", "o", "O")
	blankLowPriority := NewReplacer("o", "O", "", "X")
	blankNoOp1 := NewReplacer("", "")
	blankNoOp2 := NewReplacer("", "", "", "A")
	blankFoo := NewReplacer("", "X", "foobar", "R", "foobaz", "Z")
	testCases = append(testCases,
		testCase{blankToX1, "foo", "XfXoXoX"},
		testCase{blankToX1, "", "X"},

		testCase{blankToX2, "foo", "XfXoXoX"},
		testCase{blankToX2, "", "X"},

  }

  public void testFindClassesToTest_ignoreUnderscores() {
    assertThat(findClassesToTest(ImmutableList.of(Foo.class, Foo_Bar.class)))
        .containsExactly(Foo.class, Foo_Bar.class);
    sanityTests.ignoreClasses(AbstractPackageSanityTests.UNDERSCORE_IN_NAME);
    assertThat(findClassesToTest(ImmutableList.of(Foo.class, Foo_Bar.class)))
        .containsExactly(Foo.class);
  }

  absl::optional<int> foo = internal::FindNodeAtPath("foo", object_graph);
  ASSERT_TRUE(foo.has_value());
  EXPECT_EQ(*foo, 1);

  absl::optional<int> foo_bar =
      internal::FindNodeAtPath("foo.bar", object_graph);
  ASSERT_TRUE(foo_bar.has_value());
  EXPECT_EQ(*foo_bar, 3);

  absl::optional<int> foo_bar_parent =
      internal::FindNodeAtPath("foo.bar.parent", object_graph);
  ASSERT_TRUE(foo_bar_parent.has_value());