TF_Status* status = TF_NewStatus();
  TF_Tensor* t = TFE_AllocateHostTensor(ctx, datatype, dims, num_dims, status);
  memcpy(TF_TensorData(t), data, TF_TensorByteSize(t));
  TFE_TensorHandle* th = TFE_NewTensorHandleFromTensor(ctx, t, status);
  CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  TF_DeleteTensor(t);
  TF_DeleteStatus(status);
  return th;
}

		})
	}
	return list, nil
}

// Stat returns the current KES status containing a
// list of KES endpoints and the default key ID.
func (c *kesConn) Status(ctx context.Context) (map[string]madmin.ItemState, error) {
	if len(c.client.Endpoints) == 1 {
		if _, err := c.client.Status(ctx); err != nil {
			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {

       <Rule>
               <ID>max-versions</ID>
               <Status>Enabled</Status>
               <NoncurrentVersionExpiration>
                       <NewerNoncurrentVersions>2</NewerNoncurrentVersions>
               </NoncurrentVersionExpiration>
       </Rule>
       <Rule>
               <ID>delete-all-versions</ID>
               <Status>Enabled</Status>
               <Filter>
                       <Tag>

        super(winerr ? getMessageByWinerrCode(errcode) : getMessageByCode(errcode));
        this.status = winerr ? errcode : getStatusByCode(errcode);
    }

    /**
     * Get the NT STATUS code associated with this exception
     *
     * @return status code
     */
    public int getNtStatus() {
        return this.status;
    }

    /**

package jcifs.smb;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verifyNoInteractions;

import java.lang.reflect.Field;

import org.junit.jupiter.api.DisplayName;

		sleep $wait_interval
	fi

	((attempt++))
done

status=$(./mc admin group info site1 site-replication-issue-group --json | jq .groupStatus | tr -d '"')

if [[ $status == "enabled" ]]; then
	echo "Success"
else
	echo "Expected status: enabled, actual status: $status"
	exit 1
fi

cleanup

## change working directory

    }

    @ParameterizedTest
    @ValueSource(ints = { NtStatus.NT_STATUS_SUCCESS, NtStatus.NT_STATUS_PENDING, NtStatus.NT_STATUS_ACCESS_DENIED,
            NtStatus.NT_STATUS_INVALID_PARAMETER })
    @DisplayName("Should handle various status codes")
    void testVariousStatusCodes(int status) {
        response.setStatusForTest(status);
        assertEquals(status, response.getErrorCode());
    }

    @ParameterizedTest

  if (shape.num_dims != -1) {
    DCHECK(shape.dim_sizes != nullptr);
    Status status = tensorflow::PartialTensorShape::MakePartialShape(
        reinterpret_cast<int64_t*>(shape.dim_sizes), shape.num_dims,
        &partial_shape);
    if (!status.ok()) {
      tsl::Set_TF_Status_from_Status(s, status);
      return nullptr;
    }
  }
  tsl::Set_TF_Status_from_Status(

		return
	}
	vars := mux.Vars(r)
	op := madmin.SiteResyncOp(vars["operation"])
	var (
		status madmin.SRResyncOpStatus
		err    error
	)
	switch op {
	case madmin.SiteResyncStart:
		status, err = globalSiteReplicationSys.startResync(ctx, objectAPI, peerSite)
	case madmin.SiteResyncCancel:
		status, err = globalSiteReplicationSys.cancelResync(ctx, objectAPI, peerSite)
	default:

			expectedErr: errInvalidStorageClass,
		},
		{
			// no transition rule