The following are generated from this model:

   * {{{./apidocs/index.html}Java sources}} with Reader and Writers for the Xpp3 XML parser, <<<ToAPiV3()>>> and <<<ToApiV4()>>> transformers, and <<<v4>>> package
     for Merger and v4 Reader and Writers for the Xpp3 XML parser,

   * A {{{./toolchains.html}Descriptor Reference}}

				t.Fatalf("unmarshalWithJSONPB(%s): got error %s", tt.desc, err)
			}

			errs := CheckIstioOperatorSpec(ispec, false)
			if gotErrs, wantErrs := errs, tt.wantErrs; !util.EqualErrors(gotErrs, wantErrs) {
				t.Errorf("ProtoToValues(%s)(%v): gotErrs:%s, wantErrs:%s", tt.desc, tt.yamlStr, gotErrs, wantErrs)
			}
		})
	}

 The following are generated from this model:

   * {{{./apidocs/index.html}Java sources}} with Reader and Writers for the Xpp3 XML parser, <<<ToAPiV3()>>> and <<<ToApiV4()>>> transformers, and <<<v4>>> package
     for Merger and v4 Reader and Writers for the Xpp3 XML parser,

   * A {{{./maven.html}Descriptor Reference}}

	wLock  mutex    // serializes writers
	writer muintptr // pending writer waiting for completing readers

	readerCount atomic.Int32 // number of pending readers
	readerWait  atomic.Int32 // number of departing readers

	readRank lockRank // semantic lock rank for read locking
}

// Lock ranking an rwmutex has two aspects:
//

 The following are generated from this model:

   * {{{./apidocs/index.html}Java sources}} with Reader and Writers for the Xpp3 XML parser, <<<ToAPiV3()>>> and <<<ToApiV4()>>> transformers, and <<<v4>>> package
     for Merger and v4 Reader and Writers for the Xpp3 XML parser,

   * A {{{./settings.html}Descriptor Reference}}

   * An {{{https://maven.apache.org/xsd/settings-1.2.0.xsd}XSD}}

	scenarios := map[string]struct {
		config   *config.KubeSchedulerConfiguration
		wantErrs field.ErrorList
	}{
		"good": {
			config: validConfig,
		},
		"bad-parallelism-invalid-value": {
			config: invalidParallelismValue,
			wantErrs: field.ErrorList{
				&field.Error{
					Type:  field.ErrorTypeInvalid,
					Field: "parallelism",
				},
			},
		},

	}
}

func nilRecorderFactory(_ string) events.EventRecorder {
	return nil
}

func checkErr(err error, wantErr string) error {
	if len(wantErr) == 0 {
		return err
	}
	if err == nil || !strings.Contains(err.Error(), wantErr) {
		return fmt.Errorf("got error %q, want %q", err, wantErr)
	}
	return nil

						Secret: "bar",
					},
				},
			},
			wantErr: true,
		},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			client := newMockClientForTest(t)
			if err := UpdateOrCreateTokens(client, tc.failIfExists, tc.tokens); (err != nil) != tc.wantErr {
				t.Fatalf("UpdateOrCreateTokens() error = %v, wantErr %v", err, tc.wantErr)
			}
		})
	}
}

)

func TestPlugin_Validate(t *testing.T) {
	tests := []struct {
		name    string
		a       admission.Attributes
		wantErr string
	}{
		{
			name: "ignored resource",
			a: &testAttributes{
				resource: schema.GroupResource{
					Group:    "foo",
					Resource: "bar",
				},
			},
			wantErr: "",
		},
		{
			name: "ignored subresource",
			a: &testAttributes{

	m.Store(make(Map))
	var mu sync.Mutex // used only by writers
	// read function can be used to read the data without further synchronization
	read := func(key string) (val string) {
		m1 := m.Load().(Map)
		return m1[key]
	}
	// insert function can be used to update the data without further synchronization
	insert := func(key, val string) {
		mu.Lock() // synchronize with other potential writers
		defer mu.Unlock()