context.unindent();
        context.println();
        context.info("Usage: mvnup [options] <goal>");
        context.println();
        context.info("Options:");
        context.indent();
        context.info("-m, --model-version <version> Target POM model version (4.0.0 or 4.1.0)");
        context.info("-d, --directory <path> Directory to use as starting point for POM discovery");

func (client *peerRESTClient) GetLocks(ctx context.Context) (lockMap map[string][]lockRequesterInfo, err error) {
	resp, err := getLocksRPC.Call(ctx, client.gridConn(), grid.NewMSS())
	if err != nil || resp == nil {
		return nil, err
	}
	return *resp, nil
}

// LocalStorageInfo - fetch server information for a remote node.
func (client *peerRESTClient) LocalStorageInfo(ctx context.Context, metrics bool) (info StorageInfo, err error) {

     *
     * @param context the query context
     * @param termQuery the term query to convert
     * @param boost the boost value to apply
     * @return the converted QueryBuilder
     */
    protected QueryBuilder convertTermQuery(final QueryContext context, final TermQuery termQuery, final float boost) {
        final String field = getSearchField(context.getDefaultField(), termQuery.getTerm().field());

        assertActivation(false, newExistsProfile("someFile.txt"), context);
        assertActivation(false, newExistsProfile("${project.basedir}/someFile.txt"), context);

        assertActivation(false, newMissingProfile(null), context);
        assertActivation(true, newMissingProfile("someFile.txt"), context);
        assertActivation(true, newMissingProfile("${project.basedir}/someFile.txt"), context);
    }

            when(mockStrategies.get(1).isApplicable(context)).thenReturn(true);
            when(mockStrategies.get(1).apply(Mockito.eq(context), Mockito.any()))
                    .thenReturn(UpgradeResult.empty());

            when(mockStrategies.get(2).isApplicable(context)).thenReturn(false);

            UpgradeResult result = orchestrator.executeStrategies(context, pomMap);

}

func (S Tracer) Warn(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Warn(ctx, s, i...)
}

func (S Tracer) Error(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Error(ctx, s, i...)
}

func (S Tracer) Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error) {
	S.Logger.Trace(ctx, begin, fc, err)
	S.Test(ctx, begin, fc, err)

        assertTrue(context.supportsAlgorithm(CompressionNegotiateContext.COMPRESSION_LZ77));
        assertTrue(context.supportsAlgorithm(CompressionNegotiateContext.COMPRESSION_LZ77_HUFFMAN));
        assertTrue(context.supportsAlgorithm(CompressionNegotiateContext.COMPRESSION_LZNT1));
        assertFalse(context.supportsAlgorithm(CompressionNegotiateContext.COMPRESSION_PATTERN_V1));
    }

    @Test
    @DisplayName("Test context encoding")

func checkGetObjArgs(ctx context.Context, bucket, object string) error {
	return checkBucketAndObjectNames(ctx, bucket, object)
}

// Checks on DeleteObject arguments, bucket and object.
func checkDelObjArgs(ctx context.Context, bucket, object string) error {
	return checkBucketAndObjectNames(ctx, bucket, object)
}

// Checks bucket and object name validity, returns nil if both are valid.

}

func (ies *IAMEtcdStore) deleteIAMConfig(ctx context.Context, path string) error {
	return deleteKeyEtcd(ctx, ies.client, path)
}

func (ies *IAMEtcdStore) loadPolicyDocWithRetry(ctx context.Context, policy string, m map[string]PolicyDoc, _ int) error {
	return ies.loadPolicyDoc(ctx, policy, m)
}

func (ies *IAMEtcdStore) loadPolicyDoc(ctx context.Context, policy string, m map[string]PolicyDoc) error {

                testEncryptionKey, testDecryptionKey);

        // When/Then - Multiple closes should be safe
        assertDoesNotThrow(() -> {
            context.close();
            context.close();
            context.close();
        });

        assertTrue(context.isClosed());
    }