public fun query (Ljava/lang/String;Lokhttp3/AsyncDns$Callback;)V
}

public final class okhttp3/android/AndroidAsyncDns$Companion {
	public final fun getIPv4 ()Lokhttp3/android/AndroidAsyncDns;
	public final fun getIPv6 ()Lokhttp3/android/AndroidAsyncDns;
}

public final class okhttp3/android/AndroidLoggingKt {

    assertThat(recordedRequest.method).isEqualTo("GET")
    assertThat(recordedRequest.path)
      .isEqualTo("/lookup?ct&dns=AAABAAABAAAAAAAABmdvb2dsZQNjb20AAAEAAQ")
  }

  @Test
  fun getIpv6() {
    server.enqueue(
      dnsResponse(
        "0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c0005000" +

	// Get object that doesn't exist
	pv, err := cache.GetPV("nothere")
	if err == nil {
		t.Errorf("GetPV() returned unexpected success")
	}
	if pv != nil {
		t.Errorf("GetPV() returned unexpected PV %q", pv.Name)
	}

	// Add a bunch of PVs
	pvs := map[string]*v1.PersistentVolume{}
	for i := 0; i < 10; i++ {
		pv := makePV(fmt.Sprintf("test-pv%v", i), "").withVersion("1").PersistentVolume
		pvs[pv.Name] = pv

	return &PVCAssumeCache{
		AssumeCache: assumecache.NewAssumeCache(logger, informer, "v1.PersistentVolumeClaim", "", nil),
		logger:      logger,
	}
}

func (c *PVCAssumeCache) GetPVC(pvcKey string) (*v1.PersistentVolumeClaim, error) {
	obj, err := c.Get(pvcKey)
	if err != nil {
		return nil, err
	}

	pvc, ok := obj.(*v1.PersistentVolumeClaim)
	if !ok {

	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotIpv4, gotIpv6 := IPsSplitV4V6(tt.args.ips)
			if !reflect.DeepEqual(gotIpv4, tt.wantIpv4) {
				t.Errorf("IPsSplitV4V6() gotIpv4 = %v, want %v", gotIpv4, tt.wantIpv4)
			}
			if !reflect.DeepEqual(gotIpv6, tt.wantIpv6) {
				t.Errorf("IPsSplitV4V6() gotIpv6 = %v, want %v", gotIpv6, tt.wantIpv6)
			}
		})
	}
}

			enableRecoverVolumeExpansionFailure: false,
			enableVolumeAttributesClass:         false,
			pvc:                                 withAllocatedResource("5G"),
			oldPVC:                              getPVC(),
			expected:                            getPVC(),
		},
		{
			name:                                "for:newPVC=hasAllocatedResource,oldPVC=doesnot,featuregate=RecoverVolumeExpansionFailure=true; should keep field",

		}
	}

	// Check pvc cache
	pvcCache := env.internalBinder.pvcCache
	for _, p := range provisionings {
		pvcKey := getPVCName(p)
		pvc, err := pvcCache.GetPVC(pvcKey)
		if err != nil {
			t.Errorf("GetPVC %q returned error: %v", pvcKey, err)
			continue
		}
		if pvc.Annotations[volume.AnnSelectedNode] != nodeLabelValue {

	ret := ""
	for _, sf := range setFlags {
		p, v := getPV(sf)
		if p == path {
			ret = v
		}
		// if set multiple times, return last set value
	}
	return ret
}

// getPV returns the path and value components for the given set flag string, which must be in path=value format.
func getPV(setFlag string) (path string, value string) {
	pv := strings.Split(setFlag, "=")

	claim := &v1.PersistentVolumeClaim{
		ObjectMeta: metav1.ObjectMeta{
			Name:      pvcName,
			Namespace: namespace,
		},
	}
	pvcKey := getPVCName(claim)
	pvc, err := b.pvcCache.GetPVC(pvcKey)
	if err != nil || pvc == nil {
		return false, nil, fmt.Errorf("error getting PVC %q: %v", pvcKey, err)
	}

	fullyBound := b.isPVCFullyBound(pvc)
	if fullyBound {

	}
	return ""
}

func (x *CNIAmbientConfig) GetDnsCapture() *wrapperspb.BoolValue {
	if x != nil {
		return x.DnsCapture
	}
	return nil
}

func (x *CNIAmbientConfig) GetIpv6() *wrapperspb.BoolValue {
	if x != nil {
		return x.Ipv6
	}
	return nil
}

type CNIRepairConfig struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache