* limitations under the License.
 */
// It might be injected by init scripts in ~/.gradle/init.d
// https://github.com/gradle/dev-infrastructure/blob/ce8651f39f370ebe5c0c3413b5ab40a05421cfb7/salt/ami-baker/ec2-build-vm-baker/provision_by_salt.sh#L172
if (tasks.findByName("resolveAllDependencies") == null) {
    tasks.register("resolveAllDependencies") {
        val npmInstall = tasks.findByName("kotlinNpmInstall")

		var fw fileWriter
		switch maker := v.maker.(type) {
		case makeReg:
			fw = &regFileWriter{w, maker.size}
			wantStr = maker.wantStr
		case makeSparse:
			if !validateSparseEntries(maker.sph, maker.size) {
				t.Fatalf("invalid sparse map: %v", maker.sph)
			}
			spd := invertSparseEntries(maker.sph, maker.size)
			fw = &regFileWriter{w, maker.makeReg.size}
			fw = &sparseFileWriter{fw, spd, 0}

		var fr fileReader
		switch maker := v.maker.(type) {
		case makeReg:
			r := testNonEmptyReader{strings.NewReader(maker.str)}
			fr = &regFileReader{r, maker.size}
		case makeSparse:
			if !validateSparseEntries(maker.spd, maker.size) {
				t.Fatalf("invalid sparse map: %v", maker.spd)
			}
			sph := invertSparseEntries(maker.spd, maker.size)
			r := testNonEmptyReader{strings.NewReader(maker.makeReg.str)}

	panic("unexpected call")
}

type faker struct {
	io.ReadWriter
}

func (f faker) Close() error                     { return nil }
func (f faker) LocalAddr() net.Addr              { return nil }
func (f faker) RemoteAddr() net.Addr             { return nil }
func (f faker) SetDeadline(time.Time) error      { return nil }
func (f faker) SetReadDeadline(time.Time) error  { return nil }

// Submitted by Tom Whitwell <******@****.***>
cloudapps.digital
london.cloudapps.digital

// GOV.UK Pay : https://www.payments.service.gov.uk/
// Submitted by Richard Baker <richard.baker@digital.cabinet-office.gov.uk>
pymnt.uk

// UKHomeOffice : https://www.gov.uk/government/organisations/home-office
// Submitted by Jon Shanks <******@****.***>
homeoffice.gov.uk

  /** Though this executor service may hold many threads, they are not executed concurrently. */
  private val tasksExecutor = Executors.newCachedThreadPool(threadFactory("TaskFaker"))

  /**
   * True if this task faker has ever had multiple tasks scheduled to run concurrently. Guarded by
   * [TaskRunner.lock].
   */
  var isParallel = false

  /** Number of calls to [TaskRunner.Backend.execute]. Guarded by [TaskRunner.lock]. */

    return Arrays.copyOfRange(source, from, to, (Class<? extends T[]>) arrayOfType.getClass());
  }

  /**
   * Configures the given map maker to use weak keys, if possible; does nothing otherwise (i.e., in
   * GWT). This is sometimes acceptable, when only server-side code could generate enough volume
   * that reclamation becomes important.
   */

    return Arrays.copyOfRange(source, from, to, (Class<? extends T[]>) arrayOfType.getClass());
  }

  /**
   * Configures the given map maker to use weak keys, if possible; does nothing otherwise (i.e., in
   * GWT). This is sometimes acceptable, when only server-side code could generate enough volume
   * that reclamation becomes important.
   */

github.com/tidwall/gjson
https://github.com/tidwall/gjson
----------------------------------------------------------------
The MIT License (MIT)

Copyright (c) 2016 Josh Baker

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in

	return &Tester{
		T:       t,
		storage: storage,
		namer:   defaultNamer,
	}
}

func defaultNamer(i int) string {
	return fmt.Sprintf("foo%d", i)
}

// Namer allows providing a custom name maker
// By default "foo%d" is used
func (t *Tester) Namer(namer func(int) string) *Tester {
	t.namer = namer
	return t
}

func (t *Tester) ClusterScope() *Tester {
	t.clusterScope = true
	return t
}