when:
        filtered.configureEach(action)

        then:
        _ * provider1.size() >> 1
        _ * provider2.size() >> 2
        0 * _

        when:
        def result = toList(filtered)

        then:
        _ * provider1.size() >> 1
        _ * provider2.size() >> 2
        1 * provider1.calculateValue(_) >> ValueSupplier.Value.of([a])

	Ocputype    uint8    // Reserved for CPU type
	Otextpsize  uint8    // Requested text page size
	Odatapsize  uint8    // Requested data page size
	Ostackpsize uint8    // Requested stack page size
	Oflags      uint8    // Flags And TLS Alignment
	Otsize      uint64   // Text Size In Bytes
	Odsize      uint64   // Data Size In Bytes
	Obsize      uint64   // Bss Size In Bytes
	Oentry      uint64   // Entry Point Address

h4 small,
h5 small,
h6 small {
	font-size: 60%;
	color: #e99b8f;
	line-height: 0;
}

h1 {
	font-size: 2.125em;
}

h2 {
	font-size: 1.6875em;
}

h3,
#toctitle,
.sidebarblock>.content>.title {
	font-size: 1.375em;
}

h4 {
	font-size: 1.125em;
}

h5 {
	font-size: 1.125em;
}

h6 {
	font-size: 1em;
}

hr {

    } else if (size < 0) {
      throw new IllegalArgumentException("negative size: " + size);
    } else { // index >= size
      return lenientFormat("%s (%s) must be less than size (%s)", desc, index, size);
    }
  }

  /**
   * Ensures that {@code index} specifies a valid <i>position</i> in an array, list or string of

				"!has(self.val1)":                                     2,
				"self.val1.all(k, size(self.val1) > 0)":               2752508,
				"self.val1.exists_one(k, size(self.val1) > 0)":        2359294,
				"!self.val1.exists_one(k, size(self.val1) > 0)":       2359295,
				"size(self.val1) == 2":                                4,
				"size(self.val1.filter(k, size(self.val1) > 1)) == 1": 6684670,
			},
		},
		{name: "objects",

    </profiles>
</project>
"""
        pomReader = new PomReader(locallyAvailableExternalResource, moduleIdentifierFactory)

        then:
        pomReader.parseActivePomProfiles().size() == 1
        pomReader.properties.size() == 7
        !pomReader.properties.containsKey('prop1')
        !pomReader.properties.containsKey('prop3')
        pomReader.properties['prop2'] == 'myproperty2'

    return nullptr;
  }
  auto mins = tensor.quantization->min;
  auto maxs = tensor.quantization->max;
  if (mins.size() != maxs.size() || mins.empty()) return nullptr;

  llvm::SmallVector<llvm::APFloat, 4> min_maxs;
  min_maxs.reserve(mins.size() * 2);
  for (int i = 0, end = mins.size(); i < end; ++i) {
    llvm::APFloat min(mins[i]);
    llvm::APFloat max(maxs[i]);
    min_maxs.push_back(min);

// TF ops to match the op semantics of Tensorflow. Basically, it does:
// 1) If the requested size is smaller or equal than the input tensorlist's
// size, rewrite it to a Slice op so that only the first 'size' rows are
// returned. 2) If the requested size is larger than the input tensorlist's
// size. We need to create an additional tensorlist with 'size - input_size'
// elements, and append it to the end of the input tensorlist.

    set("a", "a", "aaa") // size 4
    set("b", "bb", "bbbb") // size 6
    assertThat(cache.size()).isEqualTo(10)

    // Cause the size to grow to 12 should evict 'A'.
    set("c", "c", "c")
    cache.flush()
    assertThat(cache.size()).isEqualTo(8)
    assertAbsent("a")
    assertValue("b", "bb", "bbbb")
    assertValue("c", "c", "c")

    // Causing the size to grow to 10 should evict nothing.

    }

    @CanIgnoreReturnValue
    Builder<K, V> combine(ImmutableSortedMap.Builder<K, V> other) {
      ensureCapacity(size + other.size);
      System.arraycopy(other.keys, 0, this.keys, this.size, other.size);
      System.arraycopy(other.values, 0, this.values, this.size, other.size);
      size += other.size;
      return this;
    }

    /**
     * Returns a newly-created immutable sorted map.
     *