final String testData;

        // This is still ambiguous and will require the @Inject annotation to be fixed
        PackagePrivateConstructorWithPrivateConstructor() {
            this("Potato");
        }

        private PackagePrivateConstructorWithPrivateConstructor(String testData) {
            this.testData = testData;
        }
    }

    route:
    - destination:
        host: sample.foo.svc.cluster.local
  - name: send /api/v1/products and /potato to sample.bar
    match:
    - name: prefix /api/v1/products
      uri:
        prefix: /api/v1/products
    - name: prefix /potato
      uri:
        prefix: /potato
    route:
    - destination:
        host: sample.bar.svc.cluster.local
        subset: v1
---
---

    def "can add type to registry that has package private constructor"() {
        when:
        def registry = new DefaultServiceRegistry()
        registry.register {
            it.add(String, "Potato")
            it.add(ModifierStubs.PackagePrivateConstructor)
        }
        then:
        noExceptionThrown()

	{Value: &Plain{[]byte("</>")}, ExpectXML: `<Plain><V>&lt;/&gt;</V></Plain>`},
	{Value: &Plain{[3]byte{'<', '/', '>'}}, ExpectXML: `<Plain><V>&lt;/&gt;</V></Plain>`},
	{Value: &Plain{NamedType("potato")}, ExpectXML: `<Plain><V>potato</V></Plain>`},
	{Value: &Plain{[]int{1, 2, 3}}, ExpectXML: `<Plain><V>1</V><V>2</V><V>3</V></Plain>`},
	{Value: &Plain{[3]int{1, 2, 3}}, ExpectXML: `<Plain><V>1</V><V>2</V><V>3</V></Plain>`},

	"post_office":                          "\U0001f3e3",
	"postal_horn":                          "\U0001f4ef",
	"postbox":                              "\U0001f4ee",
	"potable_water":                        "\U0001f6b0",
	"potato":                               "\U0001f954",
	"potted_plant":                         "\U0001fab4",
	"pouch":                                "\U0001f45d",
	"poultry_leg":                          "\U0001f357",

	return a
}

// Issue 18254: rotate after inlining
func f32(x uint32) uint32 {
	// amd64:"ROLL\t[$]7"
	return rot32nc(x, 7)
}

func doubleRotate(x uint64) uint64 {
	x = (x << 5) | (x >> 59)
	// amd64:"ROLQ\t[$]15"
	// arm64:"ROR\t[$]49"
	x = (x << 10) | (x >> 54)
	return x
}

// --------------------------------------- //
//    Combined Rotate + Masking operations //

	// a copy of root cert from config map for verification.
	certItem0 := loadCert(rotator)

	// Change grace period percentage to 100, so that root cert is guarantee to rotate.
	rotator.config.certInspector = certutil.NewCertUtil(100)
	// Rotate the root certificate now.
	rotator.checkAndRotateRootCert()
	certItem1 := loadCert(rotator)

	}
	return rotator
}

// Run refreshes root certs and updates config map accordingly.
func (rotator *SelfSignedCARootCertRotator) Run(stopCh chan struct{}) {
	if rotator.config.enableJitter {
		rootCertRotatorLog.Infof("Jitter is enabled, wait %s before "+
			"starting root cert rotator.", rotator.backOffTime.String())
		select {
		case <-time.After(rotator.backOffTime):

	}, ObjectOptions{
		VersionID: oi.VersionID,
		NoLock:    true,
	}); err != nil {
		return err
	}

	return nil
}

const (
	batchKeyRotationName               = "batch-rotate.bin"
	batchKeyRotationFormat             = 1
	batchKeyRotateVersionV1            = 1
	batchKeyRotateVersion              = batchKeyRotateVersionV1
	batchKeyRotateAPIVersion           = "v1"

}

// serverOffset returns an offset that can be used to determine
// indices of servers in c.servers when making queries.
// When the rotate option is enabled, this offset increases.
// Otherwise it is always 0.
func (c *dnsConfig) serverOffset() uint32 {
	if c.rotate {
		return atomic.AddUint32(&c.soffset, 1) - 1 // return 0 to start
	}
	return 0