//
// This changes both the promises and execpromises; use PledgePromises or
// PledgeExecpromises to only change the promises or execpromises
// respectively.
//
// For more information see pledge(2).
func Pledge(promises, execpromises string) error {
	if err := pledgeAvailable(); err != nil {
		return err
	}

	pptr, err := BytePtrFromString(promises)
	if err != nil {
		return err
	}

  let summary = "Allocate futures and corresponding promises";

  let description = [{
    Allocate futures and corresponding promises.

    $num: The number of futures to be allocated.

    $promises: There are $num promises, and promises[i] shares the state with futures[i].
    $futures: There are $num futures, and futures[i] shares the state with promises[i].
  }];

  let arguments = (ins
    I32Attr:$num

    headersDelayAmount = delay
    headersDelayUnit = unit
  }

  fun getHeadersDelay(unit: TimeUnit): Long = unit.convert(headersDelayAmount, headersDelayUnit)

  fun withPush(promise: PushPromise) =
    apply {
      promises.add(promise)
    }

  fun withSettings(settings: Settings) =
    apply {
      this.settings = settings
    }

  fun withWebSocketUpgrade(listener: WebSocketListener) =

import * as fs from 'fs'

async function modifyOpenAPIFile(filePath) {
  try {
    const data = await fs.promises.readFile(filePath)
    const openapiContent = JSON.parse(data)

    const paths = openapiContent.paths
    for (const pathKey of Object.keys(paths)) {
      const pathData = paths[pathKey]
      for (const method of Object.keys(pathData)) {
        const operation = pathData[method]
        if (operation.tags && operation.tags.length > 0) {

}

def PromiseOp: TensorflowMlrt_Op<"promise", []> {
  let summary = "Set a tensor in a promise";

  let description = [{
    Set a tensor in a promise.

    $promise: A value of type !mlrt.promise. The underlying value must be a tensorflow tensor.
    $tensor: A tensorflow tensor.
  }];

  let arguments = (ins
    MlrtPromiseType:$promise,
    TFTensorType:$tensor
  );

  func.return
}

// -----

// Test correctness when there are both data and control promises in a stream function.

// CHECK-LABEL: func private @main_stream_1
// CHECK-SAME: ([[PROMISE:%.*]]: !mlrt.promise, [[CONTROL_PROMISE:%.*]]: !mlrt.promise)
// CHECK: tf.DummySideEffecting
// CHECK: "tf_mlrt.tf_promise"([[PROMISE]]
// CHECK: mlrt.promise_control [[CONTROL_PROMISE]]

func.func @main() -> tensor<i32> {

  // CHECK: tf_mlrt.promise [[promise_b]], [[b]]
  "tf_mlrt.tf_promise"(%promise_b, %b) : (!mlrt.promise, tensor<i32>) -> ()
  // CHECK: return
  return
}

// CHECK-LABEL: @main_stream_1
// CHECK-SAME: ([[input1:%.*]]: !tf_mlrt.tensor, [[promise_c:%.*]]: !mlrt.promise, [[promise_d:%.*]]: !mlrt.promise)
func.func @main_stream_1(%input1: tensor<i32>, %promise_c: !mlrt.promise, %promise_d: !mlrt.promise) {

  // stream.
  void WaitForDefinitionEventOnStream(se::Stream* stream);

  // (Re)sets the definition event of the tensor to 'event', and promises that
  // the tensor has already been defined on stream. Removes any previous
  // definition event or any previous promises about the tensor being defined on
  // streams.
  // It is legal to reset the definition event of a tensor when overwriting the

See the License for the specific language governing permissions and
limitations under the License.
*/

package promise

import (
	"sync"

	"k8s.io/apimachinery/pkg/util/runtime"
	"k8s.io/apiserver/pkg/util/flowcontrol/counter"
	promiseifc "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise"
)

// countingPromise implements the WriteOnce interface.
// This implementation is based on a condition variable.

		}
	}()

	// Send an HTTP request to the test server.
	req, err := http.NewRequest("PUT", ts.URL, bodyReader)
	if err != nil {
		log.Fatal(err)
	}

	// Note that passing req to http.Client.Do promises that it
	// will close the body, in this case bodyReader.
	resp, err := ts.Client().Do(req)
	if err != nil {
		log.Fatal(err)
	}

	// Check whether there was an error compressing the data.