Parameter Description Generation

@Override protected Iterator<URL> getConfigurationUrls(String fileName) throws IOException {
URL url=null;
if (baseDir != null) {
url=findInFileSystem(fileName);
if (url == null) {
return super.getConfigurationUrls(fileName);
}
}
if (url != null) {
List<URL> list=new ArrayList<>();
list.add(url);
return list.iterator();
}
else {
return super.getConfigurationUrls(fileName);
}
}

Parameters to be described: fileName
Reference: The file name to retrieve
output_1: name of the configuration file to locate.
output_2: the name of the file
output_3: the name of the file

protected void putProperty(Map propertyMap,InternalContextAdapter contextAdapter,Node node) throws ParseErrorException, MethodInvocationException {
String param=node.value(contextAdapter).toString();
int idx=param.indexOf('=');
if (idx != -1) {
String property=param.substring(0,idx);
String value=param.substring(idx + 1);
propertyMap.put(property,value);
}
else {
throw new ParseErrorException("#" + this.getName() + " arguments must include an assignment operator! For example #tag( Component \"template=mytemplate\" ). #tag( TextField \"mytemplate\" ) is illegal!");
}
}

Parameters to be described: contextAdapter
Reference: the context adapter
output_1: the context for evaluating node values.
output_2: the name of the file
output_3: the node to be added to the map

public static String interpreterCall(boolean isTagFile,String expression,Class expectedType,String fnmapvar,boolean XmlEscape){
String jspCtxt=null;
if (isTagFile) jspCtxt="this.getJspContext()";
else jspCtxt="_jspx_page_context";
String targetType=expectedType.getName();
String primitiveConverterMethod=null;
if (expectedType.isPrimitive()) {
if (expectedType.equals(Boolean.TYPE)) {
targetType=Boolean.class.getName();
primitiveConverterMethod="booleanValue";
}
else if (expectedType.equals(Byte.TYPE)) {
targetType=Byte.class.getName();
primitiveConverterMethod="byteValue";
}
else if (expectedType.equals(Character.TYPE)) {
targetType=Character.class.getName();
primitiveConverterMethod="charValue";
}
else if (expectedType.equals(Short.TYPE)) {
targetType=Short.class.getName();
primitiveConverterMethod="shortValue";
}
else if (expectedType.equals(Integer.TYPE)) {
targetType=Integer.class.getName();
primitiveConverterMethod="intValue";
}
else if (expectedType.equals(Long.TYPE)) {
targetType=Long.class.getName();
primitiveConverterMethod="longValue";
}
else if (expectedType.equals(Float.TYPE)) {
targetType=Float.class.getName();
primitiveConverterMethod="floatValue";
}
else if (expectedType.equals(Double.TYPE)) {
targetType=Double.class.getName();
primitiveConverterMethod="doubleValue";
}
}
if (primitiveConverterMethod != null) {
XmlEscape=false;
}
targetType=toJavaSourceType(targetType);
StringBuilder call=new StringBuilder("(" + targetType + ") "+ "org.apache.struts2.jasper.runtime.PageContextImpl.proprietaryEvaluate"+ "("+ Generator.quote(expression)+ ", "+ targetType+ ".class, "+ "(PageContext)"+ jspCtxt+ ", "+ fnmapvar+ ", "+ XmlEscape+ ")");
if (primitiveConverterMethod != null) {
call.insert(0,"(");
call.append(")." + primitiveConverterMethod + "()");
}
return call.toString();
}

Parameters to be described: XmlEscape
Reference: True if the result should do XML escaping
output_1: whether to escape XML characters in the expression result.
output_2: the name of the class
output_3: the expected type of the expression

public static AnnotatedType getFieldType(Field field,AnnotatedType declaringType){
AnnotatedType exactDeclaringType=GenericTypeReflector.getExactSuperType(capture(declaringType),field.getDeclaringClass());
if (isMissingTypeParameters(exactDeclaringType.getType())) {
return field.getAnnotatedType();
}
return GenericTypeReflector.getFieldType(field,declaringType);
}

Parameters to be described: declaringType
Reference: The declaring annotated type against which to resolve the field type
output_1: the annotated type of the class declaring the field.
output_2: the class of the class
output_3: The field to get the type for

protected List<Method> findAnnotatedMethods(List<Class<?>> locations,Class<? extends Annotation> annotationClass){
List<Method> result=new ArrayList<Method>();
for ( Class<?> location : locations) {
List<Method> intermediateResult=new ArrayList<Method>();
Class<?> currentClass=location;
while (currentClass != null) {
for ( Method method : sorted(currentClass.getDeclaredMethods())) {
Annotation foundAnnotation=method.getAnnotation(annotationClass);
if (foundAnnotation != null && !isMethodShadowedBy(method,intermediateResult)) {
intermediateResult.add(method);
}
}
currentClass=currentClass.getSuperclass();
}
result.addAll(intermediateResult);
}
return result;
}

Parameters to be described: locations
Reference: denote where to search for methods
output_1: classes to search for annotated methods.
output_2: the locations to search
output_3: the annotation to search for

@Override public RecordId setHead(@NotNull Function<RecordId,RecordId> newHead,@NotNull Option... options) throws InterruptedException {
checkBound();
TimeOutOption timeout=getTimeout(options);
if (rwLock.writeLock().tryLock(timeout.time,timeout.unit)) {
try {
RecordId after=newHead.apply(getHead());
if (after != null) {
head.set(after);
return after;
}
else {
return null;
}
}
finally {
rwLock.writeLock().unlock();
}
}
else {
return null;
}
}

Parameters to be described: newHead
Reference: function mapping an record id to the record id to whichthe current head id should be set. If it returns {@code null} the head remains unchanged and {@code setHead}returns {@code false}.
output_1: function to determine the new head record ID.
output_2: the {@link return to use
output_3: the {@link Function} to apply to the head of the record

@RequestMapping(value="",method=RequestMethod.POST,params="name") @ResponseStatus(HttpStatus.CREATED) public long launch(@RequestParam("name") String taskName,@RequestParam(required=false) String properties,@RequestParam(required=false) String arguments){
SchemaVersionTarget schemaVersionTarget=aggregateExecutionSupport.findSchemaVersionTarget(taskName,taskDefinitionReader);
if (!schemaVersionTarget.equals(SchemaVersionTarget.defaultTarget())) {
Link link=linkTo(methodOn(TaskExecutionController.class).launchBoot3(taskName,properties,arguments)).withRel("launch");
throw new ApiNotSupportedException(String.format("Task: %s cannot be launched for %s. Use %s",taskName,SchemaVersionTarget.defaultTarget().getName(),link.getHref()));
}
Map<String,String> propertiesToUse=DeploymentPropertiesUtils.parse(properties);
List<String> argumentsToUse=DeploymentPropertiesUtils.parseArgumentList(arguments," ");
LaunchResponse launchResponse=this.taskExecutionService.executeTask(taskName,propertiesToUse,argumentsToUse);
return launchResponse.getExecutionId();
}

Parameters to be described: arguments
Reference: the runtime commandline arguments
output_1: optional task command line arguments.
output_2: the arguments to pass
output_3: name of the task

protected boolean lookAhead(int distance,TokenKind desiredTokenKind){
if ((position + distance) >= tokenStream.size()) {
return false;
}
Token t=tokenStream.get(position + distance);
return t.kind == desiredTokenKind;
}

Parameters to be described: distance
Reference: number of token positions past the current position
output_1: how many tokens ahead to check.
output_2: the distance to check
output_3: the kind of the token

boolean dropSession(final String clientId,boolean removeSessionState){
LOG.debug("Disconnecting client: {}",clientId);
if (clientId == null) {
return false;
}
final Session client=pool.get(clientId);
if (client == null) {
LOG.debug("Client {} not found, nothing disconnected",clientId);
return false;
}
client.closeImmediately();
if (removeSessionState) {
purgeSessionState(client);
}
LOG.debug("Client {} successfully disconnected from broker",clientId);
return true;
}

Parameters to be described: removeSessionState
Reference: boolean flag to request the removal of session state from broker.
output_1: whether to delete the session state after disconnection.
output_2: the name of the string
output_3: the id of the client to drop

private @Nullable String readResponseTopic(final @NotNull ClientConnectionContext clientConnectionContext,final @NotNull ByteBuf buf,@Nullable String responseTopic){
if (responseTopic != null) {
connackByMoreThanOnce(clientConnectionContext,"response topic");
return null;
}
responseTopic=MqttBinaryData.decodeString(buf,validateUTF8);
if (responseTopic == null) {
mqttConnacker.connackError(clientConnectionContext.getChannel(),"A client (IP: {}) sent a CONNECT with a malformed UTF-8 string for response topic. This is not allowed.","Sent a CONNECT with a malformed UTF-8 string for response topic",Mqtt5ConnAckReasonCode.MALFORMED_PACKET,ReasonStrings.CONNACK_MALFORMED_RESPONSE_TOPIC);
return null;
}
if (topicInvalid(clientConnectionContext,responseTopic,"will response topic")) {
return null;
}
return responseTopic;
}

Parameters to be described: buf
Reference: the encoded ByteBuf of the message
output_1: buffer containing the raw response topic data.
output_2: the buffer to read
output_3: the {@link ByteBuf} containing the message

private double getStandardDeviation(Map<Long,Pair<Long,Long>> storageCapacities){
double[] freeCapacities=storageCapacities.values().stream().mapToDouble(x -> ((double)x.first() / x.second())).toArray();
double mean=calculateStorageMean(freeCapacities);
return (calculateStorageStandardDeviation(freeCapacities,mean) / mean);
}

Parameters to be described: storageCapacities
Reference: Map comprising the metrics(free and total capacities) of the images stores considered
output_1: mapping of storage identifiers to pairs of used and total capacities.
output_2: the number of the /
output_3: storage capacities to calculate standard deviation for

private TemplateInfo createManagedTemplateVolume(TemplateInfo srcTemplateInfo,PrimaryDataStore destPrimaryDataStore){
TemplateInfo templateOnPrimary=(TemplateInfo)destPrimaryDataStore.create(srcTemplateInfo,srcTemplateInfo.getDeployAsIsConfiguration());
VMTemplateStoragePoolVO templatePoolRef=_tmpltPoolDao.findByPoolTemplate(destPrimaryDataStore.getId(),templateOnPrimary.getId(),srcTemplateInfo.getDeployAsIsConfiguration());
if (templatePoolRef == null) {
throw new CloudRuntimeException("Failed to find template " + srcTemplateInfo.getUniqueName() + " in storage pool "+ destPrimaryDataStore.getId());
}
else if (templatePoolRef.getState() == ObjectInDataStoreStateMachine.State.Ready) {
return templateOnPrimary;
}
int storagePoolMaxWaitSeconds=NumbersUtil.parseInt(configDao.getValue(Config.StoragePoolMaxWaitSeconds.key()),3600);
long templatePoolRefId=templatePoolRef.getId();
templatePoolRef=_tmpltPoolDao.acquireInLockTable(templatePoolRefId,storagePoolMaxWaitSeconds);
if (templatePoolRef == null) {
throw new CloudRuntimeException("Unable to acquire lock on VMTemplateStoragePool: " + templatePoolRefId);
}
try {
templateOnPrimary.processEvent(Event.CreateOnlyRequested);
CreateAsyncCompleteCallback callback=new CreateAsyncCompleteCallback();
destPrimaryDataStore.getDriver().createAsync(destPrimaryDataStore,templateOnPrimary,callback);
if (callback.result == null || callback.result.isFailed()) {
String errMesg;
if (callback.result == null) {
errMesg="Unknown/unable to determine result";
}
else {
errMesg=callback.result.getResult();
}
templateOnPrimary.processEvent(Event.OperationFailed);
throw new CloudRuntimeException("Unable to create template " + templateOnPrimary.getId() + " on primary storage "+ destPrimaryDataStore.getId()+ ":"+ errMesg);
}
templateOnPrimary.processEvent(Event.OperationSuccessed);
}
catch ( Throwable e) {
s_logger.debug("Failed to create template volume on storage",e);
templateOnPrimary.processEvent(Event.OperationFailed);
throw new CloudRuntimeException(e.getMessage());
}
finally {
_tmpltPoolDao.releaseFromLockTable(templatePoolRefId);
}
return templateOnPrimary;
}

Parameters to be described: destPrimaryDataStore
Reference: Managed storage on which we need to create the volume
output_1: the target primary data store for the template volume.
output_2: the template to create the template
output_3: template info for the source

protected File swiftWriteMetadataFile(String metaFileName,String uniqueName,String filename,long size,long virtualSize) throws IOException {
File metaFile=new File(metaFileName);
FileWriter writer=new FileWriter(metaFile);
BufferedWriter bufferWriter=new BufferedWriter(writer);
bufferWriter.write("uniquename=" + uniqueName);
bufferWriter.write("\n");
bufferWriter.write("filename=" + filename);
bufferWriter.write("\n");
bufferWriter.write("size=" + size);
bufferWriter.write("\n");
bufferWriter.write("virtualsize=" + virtualSize);
bufferWriter.close();
writer.close();
return metaFile;
}

Parameters to be described: virtualSize
Reference: :attribute: virtual size of the template
output_1: the logical or apparent size.
output_2: the directory to the directory
output_3: #NAME?

public Builder addSanDnsnames(java.lang.String value){
if (value == null) {
throw new NullPointerException();
}
ensureSanDnsnamesIsMutable();
sanDnsnames_.add(value);
bitField0_|=0x00000080;
onChanged();
return this;
}

Parameters to be described: value
Reference: The sanDnsnames to add.
output_1: a DNS name to add to the SAN list.
output_2: the bytes of the value to add.
output_3: The sanDnsnames to add.

public Builder setDeny(int index,java.lang.String value){
if (value == null) {
throw new NullPointerException();
}
ensureDenyIsMutable();
deny_.set(index,value);
bitField0_|=0x00000004;
onChanged();
return this;
}

Parameters to be described: value
Reference: The deny to set.
output_1: the string to assign at the specified index.
output_2: the outputintname to set.
output_3: The index to set the value at.

public Builder setIncludedPermissions(int index,java.lang.String value){
if (value == null) {
throw new NullPointerException();
}
ensureIncludedPermissionsIsMutable();
includedPermissions_.set(index,value);
bitField0_|=0x00000008;
onChanged();
return this;
}

Parameters to be described: value
Reference: The includedPermissions to set.
output_1: the permission string to set at the specified index.
output_2: the outputintname to set.
output_3: The index to set the value at.

public Builder setServingConfigIds(int index,java.lang.String value){
if (value == null) {
throw new NullPointerException();
}
ensureServingConfigIdsIsMutable();
servingConfigIds_.set(index,value);
bitField0_|=0x00000001;
onChanged();
return this;
}

Parameters to be described: index
Reference: The index to set the value at.
output_1: position at which to set the serving configuration ID.
output_2: the index to set the value at.
output_3: The index to set the value at.

public Builder setIntentDisplayNames(int index,java.lang.String value){
if (value == null) {
throw new NullPointerException();
}
ensureIntentDisplayNamesIsMutable();
intentDisplayNames_.set(index,value);
bitField0_|=0x00000001;
onChanged();
return this;
}

Parameters to be described: value
Reference: The intentDisplayNames to set.
output_1: the display name to set at the specified index.
output_2: the outputintname to set.
output_3: The intentDisplayNames to set.

public Builder addCardLabels(com.google.recaptchaenterprise.v1.FraudSignals.CardSignals.CardLabel value){
if (value == null) {
throw new NullPointerException();
}
ensureCardLabelsIsMutable();
cardLabels_.add(value.getNumber());
onChanged();
return this;
}

Parameters to be described: value
Reference: The cardLabels to add.
output_1: the card label to add.
output_2: the bytes of the value to add.
output_3: The cardLabels to add.

public Builder addAllApplicableCountries(java.lang.Iterable<java.lang.String> values){
ensureApplicableCountriesIsMutable();
com.google.protobuf.AbstractMessageLite.Builder.addAll(values,applicableCountries_);
bitField0_|=0x00000100;
onChanged();
return this;
}

Parameters to be described: values
Reference: The applicableCountries to add.
output_1: a collection of country codes to add.
output_2: the enum to add.
output_3: The applicableCountries to add.

@java.lang.Deprecated public Builder addAllAllowedMachineTypes(java.lang.Iterable<java.lang.String> values){
ensureAllowedMachineTypesIsMutable();
com.google.protobuf.AbstractMessageLite.Builder.addAll(values,allowedMachineTypes_);
bitField0_|=0x00000001;
onChanged();
return this;
}

Parameters to be described: values
Reference: The allowedMachineTypes to add.
output_1: the machine types to add.
output_2: the values to add.
output_3: The allowedMachineTypes to add.

public Builder setHealthChecks(int index,java.lang.String value){
if (value == null) {
throw new NullPointerException();
}
ensureHealthChecksIsMutable();
healthChecks_.set(index,value);
bitField0_|=0x00000010;
onChanged();
return this;
}

Parameters to be described: value
Reference: The healthChecks to set.
output_1: the health check string to set.
output_2: the outputintname to set.
output_3: The healthChecks to set.

public Builder setTunnels(int index,java.lang.String value){
if (value == null) {
throw new NullPointerException();
}
ensureTunnelsIsMutable();
tunnels_.set(index,value);
bitField0_|=0x00001000;
onChanged();
return this;
}

Parameters to be described: value
Reference: The tunnels to set.
output_1: the tunnel string to set.
output_2: the outputintname to set.
output_3: The index to set the value at.

public Builder addDeviceIds(java.lang.String value){
if (value == null) {
throw new NullPointerException();
}
ensureDeviceIdsIsMutable();
deviceIds_.add(value);
bitField0_|=0x00000004;
onChanged();
return this;
}

Parameters to be described: value
Reference: The deviceIds to add.
output_1: the device ID to add.
output_2: the bytes of the value to add.
output_3: The deviceIds to add.

public final String dumpImageFile(final File file) throws ImagingException, IOException {
if (!canAcceptExtension(file)) {
return null;
}
if (LOGGER.isLoggable(Level.FINEST)) {
LOGGER.finest(getName() + ": " + file.getName());
}
return dumpImageFile(ByteSource.file(file));
}

Parameters to be described: file
Reference: A valid file reference.
output_1: the image file to be processed.
output_2: the file to search
output_3: the file to dump

@Override public BasicKeyChain toEncrypted(KeyCrypter keyCrypter,AesKey aesKey){
lock.lock();
try {
Objects.requireNonNull(keyCrypter);
checkState(this.keyCrypter == null,() -> "key chain is already encrypted");
BasicKeyChain encrypted=new BasicKeyChain(keyCrypter);
for ( ECKey key : hashToKeys.values()) {
ECKey encryptedKey=key.encrypt(keyCrypter,aesKey);
if (!ECKey.encryptionIsReversible(key,encryptedKey,keyCrypter,aesKey)) throw new KeyCrypterException("The key " + key.toString() + " cannot be successfully decrypted after encryption so aborting wallet encryption.");
encrypted.importKeyLocked(encryptedKey);
}
for ( ListenerRegistration<KeyChainEventListener> listener : listeners) {
encrypted.addEventListener(listener);
}
return encrypted;
}
finally {
lock.unlock();
}
}

Parameters to be described: aesKey
Reference: AES key to use (normally created using KeyCrypter#deriveKey and cached as it is time consumingto create from a password)
output_1: the AES key used for encryption.
output_2: the key of the encryption
output_3: the key crypter to use for encryption

public MonetaryFormat repeatOptionalDecimals(int decimals,int repetitions){
checkArgument(repetitions >= 0,() -> "repetitions cannot be negative: " + repetitions);
List<Integer> decimalGroups=new ArrayList<>(repetitions);
for (int i=0; i < repetitions; i++) decimalGroups.add(decimals);
return new MonetaryFormat(negativeSign,positiveSign,zeroDigit,decimalMark,minDecimals,decimalGroups,shift,roundingMode,codes,codeSeparator,codePrefixed);
}

Parameters to be described: repetitions
Reference: number of repetitions
output_1: number of times to repeat the optional decimal groups.
output_2: the number of columns to be added
output_3: The number of digits to repeat.

public static void writeInt16LE(int val,OutputStream stream) throws IOException {
byte[] buf=new byte[2];
writeInt16LE(val,ByteBuffer.wrap(buf));
stream.write(buf);
}

Parameters to be described: val
Reference: value to be written
output_1: the 16-bit integer to write.
output_2: the byte to write
output_3: the stream to write to

static InetSocketAddress parse(final String value,final String uriParamName,final boolean isReResolution,final NameResolver nameResolver){
if (Strings.isEmpty(value)) {
throw new NullPointerException("input string must not be null or empty");
}
final String nameAndPort=nameResolver.lookup(value,uriParamName,isReResolution);
InetSocketAddress address=tryParseIpV4(nameAndPort,uriParamName,isReResolution,nameResolver);
if (null == address) {
address=tryParseIpV6(nameAndPort,uriParamName,isReResolution,nameResolver);
}
if (null == address) {
throw new IllegalArgumentException("invalid format: " + value);
}
return address;
}

Parameters to be described: uriParamName
Reference: for the parse.
output_1: the name of the URI parameter for error messages.
output_2: the name of the address=tryparseipv6(nameandport,uriparamname,isreresolution,nameresolver);
output_3: the name resolver to use

public void onResponseSetup(final ResponseSetupFlyweight msg,final UnsafeBuffer unsafeBuffer,final int length,final InetSocketAddress srcAddress,final DriverConductorProxy conductorProxy){
final long key=compoundKey(msg.sessionId(),msg.streamId());
final NetworkPublication publication=publicationBySessionAndStreamId.get(key);
if (null != publication) {
final long responseCorrelationId=publication.responseCorrelationId();
if (Aeron.NULL_VALUE != responseCorrelationId) {
conductorProxy.responseSetup(responseCorrelationId,msg.responseSessionId());
}
}
}

Parameters to be described: msg
Reference: of the Response Setup frame.
output_1: the response setup message received.
output_2: the message to send
output_3: the {@link DriverConductorProxy} to use for this connection

public static int findNumberOfAddressesByRegistrationId(final CountersReader countersReader,final long registrationId){
int result=0;
for (int i=0, size=countersReader.maxCounterId(); i < size; i++) {
final int counterState=countersReader.getCounterState(i);
if (counterState == RECORD_ALLOCATED && countersReader.getCounterTypeId(i) == LOCAL_SOCKET_ADDRESS_STATUS_TYPE_ID && countersReader.getCounterRegistrationId(i) == registrationId) {
result++;
}
else if (RECORD_UNUSED == counterState) {
break;
}
}
return result;
}

Parameters to be described: registrationId
Reference: for the subscription.
output_1: the identifier to match registration records.
output_2: the current number of the record_allocated
output_3: the counter id

public static BitFieldGet create(BitFieldType type,Offset offset){
Assert.notNull(type,"BitFieldType must not be null");
Assert.notNull(offset,"Offset must not be null");
BitFieldGet instance=new BitFieldGet();
instance.type=type;
instance.offset=offset;
return instance;
}

Parameters to be described: type
Reference: must not be {@literal null}.
output_1: the bit field's data type.
output_2: must not be {@literal null}.
output_3: the offset of the bit field

public CellIterator getTreeCellIterator(Shape shape,int detailLevel){
if (detailLevel > maxLevels) {
throw new IllegalArgumentException("detailLevel > maxLevels");
}
return new TreeCellIterator(shape,detailLevel,getWorldCell());
}

Parameters to be described: detailLevel
Reference: the maximum detail level to get cells for
output_1: the granularity level of detail.
output_2: the maximum number of the last
output_3: the shape of the tree

public static String[] getExecutorCommand(Config config,Config runtime,String shardId,Map<ExecutorPort,String> ports){
List<String> commands=new ArrayList<>();
commands.add(Context.executorBinary(config));
String[] commandArgs=executorCommandArgs(config,runtime,ports,shardId);
commands.addAll(Arrays.asList(commandArgs));
return commands.toArray(new String[0]);
}

Parameters to be described: shardId
Reference: the executor/container index
output_1: identifier for the process shard.
output_2: raft shard id
output_3: the runtime configuration

@VisibleForTesting protected void configureContainerPorts(boolean remoteDebugEnabled,int numberOfInstances,final V1Container container){
List<V1ContainerPort> ports=new ArrayList<>(getExecutorPorts());
if (remoteDebugEnabled) {
ports.addAll(getDebuggingPorts(numberOfInstances));
}
KubernetesUtils.CommonUtils<V1ContainerPort> utils=new KubernetesUtils.CommonUtils<>();
container.setPorts(utils.mergeListsDedupe(getExecutorPorts(),container.getPorts(),Comparator.comparing(V1ContainerPort::getContainerPort),"Pod Template Ports"));
}

Parameters to be described: remoteDebugEnabled
Reference: Flag used to indicate if debugging ports need to be added.
output_1: whether remote debugging is enabled.
output_2: the {@link protected to use
output_3: The number of instances to configure

V1PersistentVolumeClaim createPersistentVolumeClaim(String claimName,Map<String,String> labels,Map<KubernetesConstants.VolumeConfigKeys,String> configs){
V1PersistentVolumeClaim claim=new V1PersistentVolumeClaimBuilder().withNewMetadata().withName(claimName).withLabels(labels).endMetadata().withNewSpec().withStorageClassName("").endSpec().build();
for ( Map.Entry<KubernetesConstants.VolumeConfigKeys,String> option : configs.entrySet()) {
String optionValue=option.getValue();
switch (option.getKey()) {
case storageClassName:
claim.getSpec().setStorageClassName(optionValue);
break;
case sizeLimit:
claim.getSpec().setResources(new V1ResourceRequirements().putRequestsItem("storage",new Quantity(optionValue)));
break;
case accessModes:
claim.getSpec().setAccessModes(Arrays.asList(optionValue.split(",")));
break;
case volumeMode:
claim.getSpec().setVolumeMode(optionValue);
break;
default :
break;
}
}
return claim;
}

Parameters to be described: claimName
Reference: Name to be assigned to <code>Persistent Volume Claims Template</code>.
output_1: the name of the volume claim.
output_2: the {@link v1persistentvolumeclaim to use
output_3: The labels of the volume.

public static void stopProxy(VersionedProtocol proxy){
if (proxy != null) {
((Invoker)Proxy.getInvocationHandler(proxy)).close();
}
}

Parameters to be described: proxy
Reference: the proxy to be stopped
output_1: the protocol instance to stop.
output_2: the proxy to check
output_3: the proxy to stop

private static <T>void assertEventuallyEquals(T expected,Callable<T> eval,int checkIntervalMillis,long timeoutMillis) throws Exception {
T result=null;
try {
result=TestUtils.awaitEvaluateExpr(expected,eval,checkIntervalMillis,timeoutMillis);
}
catch ( TimeoutException e) {
throw e;
}
assertEquals(expected,result);
}

Parameters to be described: timeoutMillis
Reference: The timeout in milliseconds after which an assertion error should be thrown.
output_1: maximum time to wait for the expected value.
output_2: the maximum timeout in milliseconds
output_3: the expected value

public boolean removeAttributes(final boolean includeSubtree,final String... attributeNames){
boolean result=false;
for ( final String name : attributeNames) {
result|=this.attributes.remove(name) != null;
}
if (includeSubtree) {
for ( final Topic c : this.children) {
result|=c.removeAttributes(includeSubtree,attributeNames);
}
}
return result;
}

Parameters to be described: includeSubtree
Reference: if true then remove all attributes from subtree
output_1: whether to remove attributes from child elements recursively.
output_2: the includesubtree to check
output_3: the attribute names to remove