// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// Slices have nil Len values in the corresponding ast.ArrayType
// node and reflect.NewValue(slice.Len) is an invalid reflect.Value.
// The rewriter must not crash in that case. Was issue 1696.

  }

  llvm::SmallVector<ElementValueT, 16> new_values;
  auto num_elements = result_type.getNumElements();
  new_values.reserve(num_elements);
  auto operand_values = operand.getValues<ElementValueT>();
  for (int64_t i = 0; i < num_elements; ++i) {
    const int64_t operand_index =
        GetElementIndex(operand_new_shape, current_index);
    new_values.push_back(*(operand_values.begin() + operand_index));

	// Cache the CPU usage every defaultCachePeriod
	go wait.Forever(func() {
		newValue := p.nodeMetrics.cpuUsageCoreNanoSeconds
		p.mu.Lock()
		defer p.mu.Unlock()
		p.cpuUsageCoreNanoSecondsCache = cpuUsageCoreNanoSecondsCache{
			previousValue: p.cpuUsageCoreNanoSecondsCache.latestValue,
			latestValue:   newValue,
		}
	}, defaultCachePeriod)

	return nil
}

                }
            }

            ${ivyTestRepository()}

            dependencies {
                featureImplementation 'org:optionaldep:1.0'
            }

            $prop = "$newValue"
        """

        when:
        def mod = ivyRepo.module(group, name, version)
        javaLibrary = javaLibrary(mod)
        run "publish"
        mod.removeGradleMetadataRedirection()

                classpath = files()
            }

            dependencies {
                featureImplementation 'org:optionaldep:1.0'
            }

            $prop = "$newValue"
        """

        when:
        def mod = mavenRepo.module(group, name, version)
        javaLibrary = javaLibrary(mod)
        run "publish"
        mod.removeGradleMetadataRedirection()

    V oldValue = table.get(row, column);
    if (oldValue == null) {
      table.put(row, column, value);
    } else {
      V newValue = mergeFunction.apply(oldValue, value);
      if (newValue == null) {
        table.remove(row, column);
      } else {
        table.put(row, column, newValue);
      }
    }
  }

  private TableCollectors() {}

	for {
		if auxIntToInt32(v.AuxInt) != 2 {
			break
		}
		cmp := v_0
		if !(buildcfg.GOPPC64 <= 9) {
			break
		}
		v.reset(OpPPC64ISELZ)
		v.AuxInt = int32ToAuxInt(2)
		v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
		v0.AuxInt = int64ToAuxInt(1)
		v.AddArg2(v0, cmp)
		return true
	}
	// match: (SETBC [0] cmp)
	// cond: buildcfg.GOPPC64 <= 9
	// result: (ISELZ [0] (MOVDconst [1]) cmp)

        mergeSpec.eachEntry {ManifestMergeDetails details ->
            if (details.getKey() == 'key2') {
                details.setValue('newValue2')
            }
        }

        expect:
        mergeSpec.merge(baseManifest, Mock(FileResolver)).attributes == [key1: 'value1', key2: 'newValue2'] + MANIFEST_VERSION_MAP
    }

    def mergeWithActionOnSection() {

      long oldValue;
      long newValue;
      do {
        oldValue = data.get(longIndex);
        newValue = oldValue | mask;
        if (oldValue == newValue) {
          return false;
        }
      } while (!data.compareAndSet(longIndex, oldValue, newValue));

      // We turned the bit on, so increment bitCount.
      bitCount.increment();

            String newValue = transform(oldValue);
            Map<String, String> oldAttrs = node.getAttributes();
            Map<String, String> newAttrs = transform(oldAttrs, this::transform);
            List<XmlNode> oldChildren = node.getChildren();
            List<XmlNode> newChildren = transform(oldChildren, this::transform);
            if (oldValue != newValue || oldAttrs != newAttrs || oldChildren != newChildren) {