override val isReady = false

  override fun connectTcp() = result

  override fun connectTlsEtc() = result

  override fun handleSuccess() = error("unexpected call")

  override fun cancel() = error("unexpected cancel")

  override fun retry() = error("unexpected retry")

// (only the config that are of concern to minio)
func (s *peerRESTServer) GetSysConfigHandler(_ *grid.MSS) (*grid.JSON[madmin.SysConfig], *grid.RemoteErr) {
	info := madmin.GetSysConfig(context.Background(), globalLocalNodeName)
	return madminSysConfig.NewJSONWith(&info), nil
}

// GetSysServicesHandler - returns system services information.
// (only the services that are of concern to minio)

      Long[] suffix = {86L, 99L};
      Long[] all = concat(concat(prefix, elements), suffix);
      return makeArray(all).subArray(2, elements.length + 2).asList();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only from suite
  private static Long[] concat(Long[] a, Long[] b) {
    return ObjectArrays.concat(a, b, Long.class);
  }

  @J2ktIncompatible

			key = key + etcdPathSeparator + ip
			ctx, cancel := context.WithTimeout(context.Background(), defaultContextTimeout)
			_, err = c.etcdClient.Put(ctx, key, string(bucketMsg))
			cancel()
			if err != nil {
				ctx, cancel = context.WithTimeout(context.Background(), defaultContextTimeout)
				c.etcdClient.Delete(ctx, key)
				cancel()
				return err
			}
		}
	}
	return nil
}

    public static final int DCERPC_FIRST_FRAG      = 0x01; /* First fragment */
    public static final int DCERPC_LAST_FRAG       = 0x02; /* Last fragment */
    public static final int DCERPC_PENDING_CANCEL  = 0x04; /* Cancel was pending at sender */
    public static final int DCERPC_RESERVED_1      = 0x08;
    public static final int DCERPC_CONC_MPX        = 0x10; /* supports concurrent multiplexing */

      Integer[] prefix = {Integer.MIN_VALUE, Integer.MAX_VALUE};
      Integer[] suffix = {(int) 86, (int) 99};
      Integer[] all = concat(concat(prefix, elements), suffix);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  private static Integer[] concat(Integer[] left, Integer[] right) {
    Integer[] result = new Integer[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);

      Byte[] prefix = {Byte.MIN_VALUE, Byte.MAX_VALUE};
      Byte[] suffix = {(byte) 86, (byte) 99};
      Byte[] all = concat(concat(prefix, elements), suffix);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  private static Byte[] concat(Byte[] left, Byte[] right) {
    Byte[] result = new Byte[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);

  }

  private static void doTestSuccessfulAsList_resultCancelledRacingInputDone() throws Exception {
    // Simple (combined.cancel -> input.cancel -> setOneValue):
    successfulAsList(ImmutableList.of(SettableFuture.create())).cancel(true);

    /*
     * Complex (combined.cancel -> input.cancel -> other.set -> setOneValue),
     * to show that this isn't just about problems with the input future we just
     * cancelled:

          this,
          IllegalStateException("Invalid content-type: ${body.contentType()}"),
          response,
        )
        return
      }

      // This is a long-lived response. Cancel full-call timeouts.
      call?.timeout()?.cancel()

      // Replace the body with a stripped one so the callbacks can't see real data.
      val response = response.stripBody()

      val reader = ServerSentEventReader(body.source(), this)

				runAllIAMSTSTests(testCase, &check{t, testCase.serverType})
			},
		)
	}
}

func (s *TestSuiteIAM) TestSTSServiceAccountsWithUsername(c *check) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	bucket := "dillon-bucket"
	err := s.client.MakeBucket(ctx, bucket, minio.MakeBucketOptions{})
	if err != nil {
		c.Fatalf("bucket create error: %v", err)
	}