ConcatenatedIterator<T> topConcat = (ConcatenatedIterator<T>) iterator;
          iterator = topConcat.iterator;

          // topConcat.topMetaIterator, then topConcat.metaIterators, then this.topMetaIterator,
          // then this.metaIterators

          if (this.metaIterators == null) {
            this.metaIterators = new ArrayDeque<>();
          }

          ConcatenatedIterator<T> topConcat = (ConcatenatedIterator<T>) iterator;
          iterator = topConcat.iterator;

          // topConcat.topMetaIterator, then topConcat.metaIterators, then this.topMetaIterator,
          // then this.metaIterators

          if (this.metaIterators == null) {
            this.metaIterators = new ArrayDeque<>();
          }

        when(kerberosKey.getKeyType()).thenReturn(ENCRYPTION_TYPE);

        try (MockedStatic<KerberosEncData> mockedEncData = Mockito.mockStatic(KerberosEncData.class)) {
            mockedEncData.when(() -> KerberosEncData.decrypt(ENCRYPTED_DATA, kerberosKey, ENCRYPTION_TYPE)).thenReturn(decryptedData);

            // When

          Reflection.newProxy(Map.class, new CheckSetUpInvocationHandler(map, setUpRan));
      return proxy;
    }
  }

  /**
   * Intercepts calls to a {@code Map} to check that {@code setUpRan} is true when they happen. Then
   * forwards the calls to the underlying {@code Map}.
   */
  private static class CheckSetUpInvocationHandler implements InvocationHandler, Serializable {
    private final Map<String, String> map;

## Required query parameters { #required-query-parameters }

When you declare a default value for non-path parameters (for now, we have only seen query parameters), then it is not required.

If you don't want to add a specific value but just make it optional, set the default as `None`.

But when you want to make a query parameter required, you can just not declare any default value:

		} else {
			builder.WriteByte('@')
			builder.WriteString(string(name))
		}
	}
}

// processValue handles different value types appropriately for SQL parameter binding
// It checks for driver.Valuer first, then handles slices/arrays, and finally adds single values
func processValue(builder Builder, value interface{}) {
	if _, ok := value.(driver.Valuer); ok {
		builder.AddVar(builder, value)
		return
	}

                    artifact.setRepository(repository);
                    break;
                }
            } catch (ResourceDoesNotExistException e) {
                // This one we will eat when looking through remote repositories
                // because we want to cycle through them all before squawking.

                logger.debug(

    }

    /**
     * Create an {@code NtlmPasswordAuthentication} object from the userinfo
     * component of an SMB URL like "{@code domain;user:pass}". This constructor
     * is used internally be jCIFS when parsing SMB URLs.
     *
     * @param tc the CIFS context to use
     * @param userInfo the user information string in the format "domain;user:pass"
     */

		keyInfos[i].Name = names[i]
	}
	return keyInfos, continueAt, nil
}

// CreateKey tries to create a new key at the KMS with the
// given key ID.
//
// If the a key with the same keyID already exists then
// CreateKey returns kes.ErrKeyExists.
func (c *kesConn) CreateKey(ctx context.Context, req *CreateKeyRequest) error {
	if err := c.client.CreateKey(ctx, req.Name); err != nil {
		if errors.Is(err, kes.ErrKeyExists) {

  if (TF_GetCode(status) != TF_OK) return nullptr;
  TFE_OpSetAttrType(op, "dtype", TF_FLOAT);
  TFE_OpAddInput(op, var_handle, status);

  // Convert 'value' to a TF_Tensor then a TFE_TensorHandle.
  std::unique_ptr<TF_Tensor, decltype(&TF_DeleteTensor)> t(
      TF_AllocateTensor(TF_FLOAT, nullptr, 0, sizeof(value)), TF_DeleteTensor);
  memcpy(TF_TensorData(t.get()), &value, TF_TensorByteSize(t.get()));