func retryOnError(err error) bool {
	if err != nil {
		return true
	}
	return false
}

func loadWebhook(configFile string, groupVersion schema.GroupVersion, retryBackoff wait.Backoff, customDial utilnet.DialFunc) (*webhook.GenericWebhook, error) {
	clientConfig, err := webhook.LoadKubeconfig(configFile, customDial)
	if err != nil {
		return nil, err
	}

	testCases := []struct {
		name                 string
		modes                []string
		policyFile           string
		webhookConfigFile    string
		webhookRetryBackoff  *wait.Backoff
		expectErr            bool
		expectErrorSubString string
	}{
		{
			name:                 "Unknown modes should return errors",
			modes:                []string{"DoesNotExist"},
			expectErr:            true,

	}
}

func retryWithExponentialBackOff(initialDuration time.Duration, fn wait.ConditionFunc) error {
	backoff := wait.Backoff{
		Duration: initialDuration,
		Factor:   3,
		Jitter:   0,
		Steps:    6,
	}
	return wait.ExponentialBackoff(backoff, fn)
}

func TestPluginRegistration(t *testing.T) {
	defer cleanup(t)

	pluginManager := newTestPluginManager(socketDir)

apiVersion: release-notes/v2
kind: feature
area: security
issue:
- 30261
releaseNotes:
- |

        /**
         * The compile stage as a descriptive String.
         * Build scripts can be processed in multiple stages, depending on the language.
         * Groovy backed build scripts are processed in two stages.
         * Kotlin backed build scripts are processed in three stages
         * */
        String getStage();
    }

    public interface Result {
    }

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package backoff

import (
	"context"
	"errors"
	"sync"
	"testing"
	"time"

	"istio.io/istio/pkg/test/util/assert"
)

func TestBackOff(t *testing.T) {
	var (
		testInitialInterval = 500 * time.Millisecond

//     activeQ when their backoff periods complete.
//   - unschedulablePods holds pods that were already attempted for scheduling and
//     are currently determined to be unschedulable.
type PriorityQueue struct {
	*nominator

	stop  chan struct{}
	clock clock.Clock

	// pod initial backoff duration.
	podInitialBackoffDuration time.Duration
	// pod maximum backoff duration.

    /**
     * Creates a new settings source backed by the specified string.
     *
     * @param settings The settings' string representation, may be empty or {@code null}.
     */
    public StringSettingsSource(CharSequence settings) {
        this(settings, null);
    }

    /**
     * Creates a new settings source backed by the specified string.
     *

      default:
        return new RegularImmutableAsList<E>(this, toArray());
    }
  }

  /** If this collection is backed by an array of its elements in insertion order, returns it. */
  Object @Nullable [] internalArray() {
    return null;
  }

  /**
   * If this collection is backed by an array of its elements in insertion order, returns the offset
   * where this collection's elements start.
   */

	return func() error { return nil }
}

func retryWithExponentialBackOff(initialDuration time.Duration, fn wait.ConditionFunc) error {
	backoff := wait.Backoff{
		Duration: initialDuration,
		Factor:   3,
		Jitter:   0,
		Steps:    4,
	}
	return wait.ExponentialBackoff(backoff, fn)
}

func waitChannelWithTimeout(ch <-chan interface{}, timeout time.Duration) error {
	timer := time.NewTimer(timeout)