{"now.with.dots/simple": "bar"},
		{"now-with.dashes-and.dots/simple": "bar"},
		{"1-num.2-num/3-num": "bar"},
		{"1234/5678": "bar"},
		{"1.2.3.4/5678": "bar"},
		{"UpperCaseAreOK123": "bar"},
		{"goodvalue": "123_-.BaR"},
	}
	for i := range successCases {
		errs := ValidateLabels(successCases[i], field.NewPath("field"))
		if len(errs) != 0 {
			t.Errorf("case[%d] expected success, got %#v", i, errs)
		}
	}

	"strings"
	"testing"

	"k8s.io/apimachinery/pkg/util/validation/field"
)

func TestIsDNS1123Label(t *testing.T) {
	goodValues := []string{
		"a", "ab", "abc", "a1", "a-1", "a--1--2--b",
		"0", "01", "012", "1a", "1-a", "1--a--b--2",
		strings.Repeat("a", 63),
	}
	for _, val := range goodValues {
		if msgs := IsDNS1123Label(val); len(msgs) != 0 {
			t.Errorf("expected true for '%s': %v", val, msgs)
		}
	}

        Object oldValue;
        synchronized (delegate) {
            oldValue = delegate.putIfAbsent(key, value);
        }
        reportAccess(key, oldValue);
        if (oldValue == null) {
            // Properties disallow null values, so it is safe to assume that the map was changed.
            reportChange(key, value);
        }
        return oldValue;

    }

    @Override

		}
		if !reflect.DeepEqual(correlatedObject.OldValue, c.OldValue) {
			return fmt.Errorf("expected old value %v, got %v", c.OldValue, correlatedObject.OldValue)
		}

		// Check that the correlated object is considered equal to the expected value
		if (c.ExpectEqual || reflect.DeepEqual(correlatedObject.Value, correlatedObject.OldValue)) != correlatedObject.CachedDeepEqual() {

        expectedPropPerProject = [a: 'rootValue', b: 'rootValue', 'a:a1': 'rootValue'] + expectedPropPerProject
        def root = multiProjectBuild('extra-properties', ['a', 'b']) {
            createDirs("a", "a/a1")
            settingsFile << "include ':a:a1'"

            buildFile << """
                ext.testProp = 'rootValue'

                task checkTestProp {
                    doLast {

package proto

import (
	wrappers "google.golang.org/protobuf/types/known/wrapperspb"
)

var (
	// BoolTrue is a bool true pointer of types.BoolValue.
	BoolTrue = &wrappers.BoolValue{
		Value: true,
	}

	// BoolFalse is a bool false pointer of types.BoolValue.
	BoolFalse = &wrappers.BoolValue{
		Value: false,
	}

                      case 6:
                        long oldValue = map.put(key, delta);
                        threadSum += delta - oldValue;
                        break;
                      case 7:
                        oldValue = map.get(key);
                        if (map.replace(key, oldValue, delta)) {
                          threadSum += delta - oldValue;
                        }
                        break;

        expect:
        extraInfo.get('foo') == 'fooValue'
        extraInfo.get('goo') == null
    }

    def "throws exception when name matches multiple keys" () {
        given:
        def extraInfo = new DefaultIvyExtraInfo([
                (new NamespaceId('http://my.extra.info', 'foo')): 'fooValue',

                            "dns": {
                              "Kind": {
                                "BoolValue": true
                              }
                            },
                            "subject": {
                              "Kind": {
                                "BoolValue": true
                              }
                            },
                            "uri": {

        when:
        def result = getMapUnderTestToWrite().put(key, newValue)

        then:
        result == oldValue
        1 * onAccess.accept(key, oldValue)
        then:
        1 * onChange.accept(key, newValue)

        where:
        key          | oldValue        | newValue
        'existing'   | 'existingValue' | 'changed'
        'missingKey' | null            | 'changed'
    }