}
}

var cutTests = []struct {
	s, sep        string
	before, after string
	found         bool
}{
	{"abc", "b", "a", "c", true},
	{"abc", "a", "", "bc", true},
	{"abc", "c", "ab", "", true},
	{"abc", "abc", "", "", true},
	{"abc", "", "", "abc", true},
	{"abc", "d", "abc", "", false},
	{"", "d", "", "", false},
	{"", "", "", "", true},
}

func TestCut(t *testing.T) {

                super.connect(snk)
                write(TextUtil.toPlatformLineSeparators("abc\n123").bytes)
                close()
            }
        })

        when:
        run "echo"

        then:
        output.contains("[abc][123]")
    }

    def "task can read stdin when stdin has unbounded length"() {
        given:
        buildFile << '''
task echo {

				_ = set1000.Contains("456")
				_ = set1000.Contains("abc")
			}
		})
		b.Run("Contains/100", func(b *testing.B) {
			for range b.N {
				_ = set100.Contains("45")
				_ = set100.Contains("abc")
			}
		})
		b.Run("Contains/2", func(b *testing.B) {
			for range b.N {
				_ = set2.Contains("1")
				_ = set2.Contains("abc")
			}
		})
	})
	b.Run("SmallSet", func(b *testing.B) {

    types = listOf(Abc::class, C::class, D::class),
    externalFunctions = listOf(::newD),
    defaultImports = listOf(DefaultFqName("com.example", "newD"))
)


object SimpleAnalysisDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        printResolutionResults(
            schema.resolve(
                """
                    val myB = b()

                    a = myB

        def initialValue = toMutable(["abc"])
        property.set(initialValue)
        assertValueIs(["abc"])
        initialValue.add("added")
        assertValueIs(["abc", "added"])
    }

    def "queries underlying provider for every call to get()"() {
        def provider = Stub(ProviderInternal)
        provider.type >> List
        provider.calculateValue(_) >>> [["123"], ["abc"]].collect { ValueSupplier.Value.of(it) }

        assertOrder(X_GT_Y, "1-abc", "1-alpha");
        assertOrder(X_GT_Y, "1-abc", "1-beta");
        assertOrder(X_GT_Y, "1-abc", "1-milestone");
        assertOrder(X_GT_Y, "1-abc", "1-rc");
        assertOrder(X_GT_Y, "1-abc", "1-snapshot");
        assertOrder(X_GT_Y, "1-abc", "1");
        assertOrder(X_GT_Y, "1-abc", "1-sp");
    }

    @Test

    this.server = server
  }

  @Test
  fun suspendCall() {
    runTest {
      server.enqueue(MockResponse(body = "abc"))

      val call = client.newCall(request)

      call.executeAsync().use {
        withContext(Dispatchers.IO) {
          assertThat(it.body.string()).isEqualTo("abc")
        }
      }
    }
  }

  @Test
  fun timeoutCall() {
    runTest {
      server.enqueue(

		expected string
	}{
		{bytes.NewBuffer([]byte("")), 0, ""},
		{bytes.NewBuffer([]byte("")), 1, ""},
		{bytes.NewBuffer([]byte("abc")), 0, "abc"},
		{bytes.NewBuffer([]byte("abc")), 1, "bc"},
		{bytes.NewBuffer([]byte("abc")), 2, "c"},
		{bytes.NewBuffer([]byte("abc")), 3, ""},
		{bytes.NewBuffer([]byte("abc")), 4, ""},
	}
	for i, testCase := range testCases {
		r := NewSkipReader(testCase.src, testCase.skipLen)

		"65xiNg"

	// oneAudString includes one `aud` claim "abc" of type string.
	oneAudString = "header.eyJhdWQiOiJhYmMiLCJleHAiOjQ3MzI5OTQ4MDEsImlhdCI6MTU3OTM5NDgwMSwiaXNzIjoidGVzdC1pc3N1ZXItMUBpc3Rpby5pbyIsInN1YiI6InN1Yi0xIn0.signature" // nolint: lll

	// twoAudList includes two `aud` claims ["abc", "xyz"] of type []string.

        "DirectoryProperty"           | "objects.directoryProperty()"         | "file('abc')"        | new File('abc')
        "DirectoryProperty"           | "objects.directoryProperty()"         | "null"               | "null"
        "RegularFileProperty"         | "objects.fileProperty()"              | "file('abc')"        | new File('abc')