}

type concreteF[RCT RC[RG], RG any] struct {
	makeFn func() Fn /* ERROR "not enough type arguments for type Fn: have 1, want 2" */ [RCT]
}

func (c *concreteF[RCT, RG]) Fn() Fn /* ERROR "not enough type arguments for type Fn: have 1, want 2" */ [RCT] {
	return c.makeFn()
}

}

type concreteF[RCT RC[RG], RG any] struct {
	makeFn func() Fn[RCT] // ERROR "not enough type arguments for type Fn: have 1, want 2"
}

func (c *concreteF[RCT, RG]) Fn() Fn[RCT] { // ERROR "not enough type arguments for type Fn: have 1, want 2"
	return c.makeFn()
}

}

type concreteF[RCT RC[RG], RG any] struct {
	makeFn FFn /* ERROR "not enough type arguments for type FFn: have 1, want 2" */ [RCT]
}

func (c *concreteF[RCT, RG]) Fn() Fn /* ERROR "not enough type arguments for type Fn: have 1, want 2" */ [RCT] {
	return c.makeFn()

}

type concreteF[RCT RC[RG], RG any] struct {
	makeFn FFn[RCT] // ERROR "not enough type arguments for type FFn: have 1, want 2"
}

func (c *concreteF[RCT, RG]) Fn() Fn[RCT] { // ERROR "not enough type arguments for type Fn: have 1, want 2"
	return c.makeFn()

	r1.Unlink(0)
	verify(t, &r1, 1, 0)
}

func makeN(n int) *Ring {
	r := New(n)
	for i := 1; i <= n; i++ {
		r.Value = i
		r = r.Next()
	}
	return r
}

func sumN(n int) int { return (n*n + n) / 2 }

func TestNew(t *testing.T) {
	for i := 0; i < 10; i++ {
		r := New(i)
		verify(t, r, i, -1)
	}
	for i := 0; i < 10; i++ {
		r := makeN(i)
		verify(t, r, i, sumN(i))
	}
}

		makeID("v2", "kind", "ns1", "name", "uid"),
		makeID("v3", "kind", "ns1", "name", "uid"),
		makeID("v4", "kind", "ns1", "name", "uid"),
		makeID("v5", "kind", "ns1", "name", "uid"),
	}
	orderedClusterReferences := []objectReference{
		makeID("v1", "kind", "", "name", "uid"),
		makeID("v2", "kind", "", "name", "uid"),
		makeID("v3", "kind", "", "name", "uid"),
		makeID("v4", "kind", "", "name", "uid"),

// license that can be found in the LICENSE file.

package types2

import (
	"strings"
	"testing"
)

// maketl makes a term list from a string of the term list.
func maketl(s string) termlist {
	s = strings.ReplaceAll(s, " ", "")
	names := strings.Split(s, "|")
	r := make(termlist, len(names))
	for i, n := range names {
		r[i] = testTerm(n)
	}
	return r
}

func TestTermlistAll(t *testing.T) {

		shouldSucceed bool
	}{
		"success-same-version": {
			oldPV:         makePV("pv1", "").withVersion("5").PersistentVolume,
			newPV:         makePV("pv1", "").withVersion("5").PersistentVolume,
			shouldSucceed: true,
		},
		"success-storageclass-same-version": {
			oldPV:         makePV("pv1", "class1").withVersion("5").PersistentVolume,
			newPV:         makePV("pv1", "class1").withVersion("5").PersistentVolume,
			shouldSucceed: true,
		},

# This workflow will build a Java project with Maven
# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven

name: Java CI with Maven

on:
  push:
    branches:
    - master
    - "*.x"
  pull_request:
    branches:
    - master
    - "*.x"

jobs:
  build:
    runs-on: ${{ matrix.os }}

    strategy:
      matrix:

# a comment
-T
3
-Drevision=1.3.0