void testDefaultConstructor() {
            // Act
            context = new EncryptionNegotiateContext();

            // Assert
            assertEquals(EncryptionNegotiateContext.NEGO_CTX_ENC_TYPE, context.getContextType());
            assertNull(context.getCiphers());
        }

        @Test
        @DisplayName("Should encode context correctly")

            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);

     *
     * @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());

 */
package okhttp3.internal.platform

import android.content.Context
import androidx.startup.Initializer

/**
 * Androidx Startup initializer to ensure that the AndroidPlatform has access to the application context.
 */
class PlatformInitializer : Initializer<Platform> {
  override fun create(context: Context): Platform {
    PlatformRegistry.applicationContext = context

    return Platform.get()
  }

        RequestTrace parentTrace = new RequestTrace("parent-context", null, "parent-data");
        RequestTrace childTrace = new RequestTrace("child-context", parentTrace, "child-data");

        assertEquals("parent-context", parentTrace.context());
        assertNull(parentTrace.parent());
        assertEquals("parent-data", parentTrace.data());

        assertEquals("child-context", childTrace.context());

        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);
    }

	if *flagCheck {
		// slow, not worth repeating in -check
		t.Skip("skipping with -check set")
	}
	testenv.MustHaveGoBuild(t)
	context := new(build.Context)
	*context = build.Default
	context.Dir = filepath.Join(testenv.GOROOT(t), "src")

	w := NewWalker(context, context.Dir)
	for _, pkg := range w.stdPackages {
		if strings.HasPrefix(pkg, "vendor/") || strings.HasPrefix(pkg, "golang.org/x/") {

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.

package cmd

import (
	"bytes"
	"context"
	"crypto/md5"
	crand "crypto/rand"
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"runtime"
	"strconv"
	"testing"

	"github.com/dustin/go-humanize"
	"github.com/minio/minio/internal/config/storageclass"
)

func TestRepeatPutObjectPart(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	var objLayer ObjectLayer

                mergeSite(tgt, src, sourceDominant, context);
            }
            mergeSite_ChildSiteUrlInheritAppendPath(tgt, src, sourceDominant, context);
        }
    }

    @Override
    protected void mergeSite(Site target, Site source, boolean sourceDominant, Map<Object, Object> context) {
        mergeSite_Id(target, source, sourceDominant, context);
        mergeSite_Name(target, source, sourceDominant, context);