}

    def "can use arbitrary separators when building bundles"() {
        builder.library("foo.bar", "foo:bar:1.0")
        builder.library("foo-baz", "foo:baz:1.0")
        builder.library("foo_qux", "foo:qux:1.0")

        builder.bundle("my", ["foo-bar", "foo_baz", "foo.qux"])
        builder.bundle("a.b", ["foo.bar"])
        builder.bundle("a_c", ["foo.bar"])

)

func TestCamelCase(t *testing.T) {
	cases := map[string]string{
		"":              "",
		"foo":           "Foo",
		"foobar":        "Foobar",
		"fooBar":        "FooBar",
		"foo_bar":       "FooBar",
		"foo-bar":       "FooBar",
		"foo_Bar":       "FooBar",
		"foo9bar":       "Foo9Bar",
		"HTTP-API-Spec": "HTTPAPISpec",
		"http-api-spec": "HttpApiSpec",
		"_foo":          "XFoo",
		"-foo":          "XFoo",

    assertEquals("FOO_BAR", UPPER_UNDERSCORE.to(UPPER_UNDERSCORE, "FOO_BAR"));
  }

  public void testConverterToForward() {
    assertEquals("FooBar", UPPER_UNDERSCORE.converterTo(UPPER_CAMEL).convert("FOO_BAR"));
    assertEquals("fooBar", UPPER_UNDERSCORE.converterTo(LOWER_CAMEL).convert("FOO_BAR"));
    assertEquals("FOO_BAR", UPPER_CAMEL.converterTo(UPPER_UNDERSCORE).convert("FooBar"));

    assertEquals("FOO_BAR", UPPER_UNDERSCORE.to(UPPER_UNDERSCORE, "FOO_BAR"));
  }

  public void testConverterToForward() {
    assertEquals("FooBar", UPPER_UNDERSCORE.converterTo(UPPER_CAMEL).convert("FOO_BAR"));
    assertEquals("fooBar", UPPER_UNDERSCORE.converterTo(LOWER_CAMEL).convert("FOO_BAR"));
    assertEquals("FOO_BAR", UPPER_CAMEL.converterTo(UPPER_UNDERSCORE).convert("FooBar"));

        def barInsight = json.project.configurations[0].moduleInsights.find({ it.module == 'foo:bar' }).insight
        barInsight.size() == 3
        barInsight[0].name == 'foo:bar:2.0'
        barInsight[0].resolvable == 'RESOLVED'
        barInsight[0].hasConflict == false
        barInsight[0].description == null
        barInsight[0].children.size() == 0

        barInsight[1].name == 'foo:bar:2.0'

compileClasspath - Compile classpath for source set 'main'.
+--- project :a
|    \\--- foo:bar:1.0 -> 3.0
|         \\--- foo:baz:5.0
+--- project :b
|    \\--- foo:bar:0.5.dont.exist -> 3.0 (*)
+--- project :c
|    \\--- foo:bar:3.0 (*)
+--- project :d
|    \\--- foo:bar:2.0 -> 3.0 (*)
\\--- project :e
     \\--- foo:bar:3.0 (*)
"""
    }

    def "renders the dependency tree"() {
        given:

        constraints {
            api 'org:foo:1.0'
        }
""")
        def foobaz = mavenHttpRepo.module('org', 'foobaz', '1.0').publish()
        def foobar = mavenHttpRepo.module('org', 'foobar', '1.0').publish()
        def foo = mavenHttpRepo.module('org', 'foo', '1.0').dependsOn(foobar).dependsOn(foobaz).publish()
        def platformGMM = mavenHttpRepo.module("org", "other-platform", "1.0")

    }

    def "suggests model paths with Levenshtein distance lower than 4"() {
        when:
        availablePaths = ["task.afoobar", "tasks.boofar", "tasks.foobar", "tasks.f", "fooba"]

        then:
        suggestionsFor("tasks.fooba") == ["tasks.foobar", "task.afoobar", "tasks.boofar"]
    }

    def "suggests model paths with Levenshtein distance lower than half it's length for strings shorter than 6 characters"() {

  public void testBase32Offset() {
    testEncodesWithOffset(base32(), "foobar", 0, 6, "MZXW6YTBOI======");
    testEncodesWithOffset(base32(), "foobar", 1, 5, "N5XWEYLS");
    testEncodesWithOffset(base32(), "foobar", 2, 3, "N5RGC===");
    testEncodesWithOffset(base32(), "foobar", 3, 1, "MI======");
    testEncodesWithOffset(base32(), "foobar", 4, 0, "");
  }

  public void testBase32Hex() {

    subject:
      - fooar Object [*]
          suggestions: foobar

  foobah { ... } @ build.gradle line 18, column 17
    subject:
      - foobah Object [*]
          suggestions: foobar

  foonar { ... } @ build.gradle line 16, column 17
    subject:
      - foonar Object [*]
          suggestions: foobar
''')
    }