`),
			KeyPath:  []interface{}{"foo", 0, "bar", "baz"},
			NewValue: "newValue",
			OldValue: "oldValue",
		},
		{
			Name: "Map used inside another map should correlate",
			RootObject: mustUnstructured(`
                foo:
                    key: keyValue
                    bar:
                        baz: newValue
            `),
			RootOldObject: mustUnstructured(`
                foo:

        then:
        result == expectedResult
        map[key] == expectedResult

        where:
        key        | newValue   | expectedResult
        'existing' | 'newValue' | 'newValue'
        'existing' | null       | null
        'missing'  | 'newValue' | 'newValue'
        'missing'  | null       | null
    }

    def "method compute(#key, #newValue) reports change"() {

	v := b.Func.newValue(op, t, b, pos)
	v.AuxInt = auxint
	v.Aux = aux
	v.Args = v.argstorage[:0]
	return v
}

// NewValue1 returns a new value in the block with one argument and zero aux values.
func (b *Block) NewValue1(pos src.XPos, op Op, t *types.Type, arg *Value) *Value {
	v := b.Func.newValue(op, t, b, pos)
	v.AuxInt = 0
	v.Args = v.argstorage[:1]

    String key = "key";
    long newValue = random.nextInt(MAX_ADDEND);
    for (int i = 0; i < ITERATIONS; i++) {
      long before = map.get(key);
      long result = map.put(key, newValue);
      long after = map.get(key);
      assertEquals(newValue, after);
      assertEquals(before, result);
      newValue += newValue;
    }
    assertEquals(1, map.size());

        try {
            return work.get();
        } catch (FileIntegrityViolationException e) {
            T newValue = updateAction.update(null);
            set(newValue);
            return newValue;
        }
    }

    String key = "key";
    long newValue = random.nextInt(MAX_ADDEND);
    for (int i = 0; i < ITERATIONS; i++) {
      long before = map.get(key);
      long result = map.put(key, newValue);
      long after = map.get(key);
      assertEquals(newValue, after);
      assertEquals(before, result);
      newValue += newValue;
    }
    assertEquals(1, map.size());

        Object oldValue;
        Object newValue;
        synchronized (delegate) {
            oldValue = delegate.get(key);
            newValue = delegate.compute(key, remappingFunction);
        }
        reportAccess(key, oldValue);
        if (newValue != null) {
            reportChange(key, newValue);
        } else if (oldValue != null) {
            reportRemoval(key);
        }

        return testString;
    }

    public void setTestString(String newValue) {
        testString = newValue;
    }

    private boolean testFlag = false;

    public boolean isTestFlag() {
        return testFlag;
    }

    public void setTestFlag(boolean newValue) {
        testFlag = newValue;
    }

    public String intercepted = null;

    @Override

    value += delta;
  }

  public int addAndGet(int delta) {
    return value += delta;
  }

  public void set(int newValue) {
    value = newValue;
  }

  public int getAndSet(int newValue) {
    int result = value;
    value = newValue;
    return result;
  }

  @Override
  public int hashCode() {
    return value;
  }

  @Override

        }

        @Override
        public void set(T newValue) {
            value = newValue;
        }

        @Override
        public T update(Function<T, T> updateFunction) {
            synchronized (this) {
                T newValue = updateFunction.apply(value);
                value = newValue;
                return newValue;
            }
        }
    }