for (int i = 0; i < numInsertions * 2; i += 2) {
      bf.put(Integer.toString(i));
    }
    assertApproximateElementCountGuess(bf, numInsertions);

    // Assert that the BF "might" have all of the even numbers.
    for (int i = 0; i < numInsertions * 2; i += 2) {
      assertTrue(bf.mightContain(Integer.toString(i)));
    }

  }

  public void testComplexBuilder() {
    List<Integer> colorElem = asList(0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF);
    ImmutableList.Builder<Integer> webSafeColorsBuilder = ImmutableList.builder();
    for (Integer red : colorElem) {
      for (Integer green : colorElem) {
        for (Integer blue : colorElem) {
          webSafeColorsBuilder.add((red << 16) + (green << 8) + blue);
        }

  // Some convenient Integer constants

  public static final Integer zero = 0;
  public static final Integer one = 1;
  public static final Integer two = 2;
  public static final Integer three = 3;
  public static final Integer four = 4;
  public static final Integer five = 5;
  public static final Integer six = 6;
  public static final Integer seven = 7;
  public static final Integer eight = 8;

     */
    Jvm(OperatingSystem os, File suppliedJavaBase, String implementationJavaVersion, Integer javaVersionMajor) {
        this(os, suppliedJavaBase, implementationJavaVersion, javaVersionMajor, true);
    }

    private Jvm(OperatingSystem os, File suppliedJavaBase, String implementationJavaVersion, Integer javaVersionMajor, boolean userSupplied) {
        this.os = os;
        this.javaBase = suppliedJavaBase;

        'Integer'  | ''                 | 'Integer.valueOf(1)'                                                | 'java.lang.Integer'
        'String'   | ''                 | 'new String()'                                                      | 'java.lang.String'
        'Iterable' | '<Integer>'        | 'Arrays.asList(Integer.valueOf(1), Integer.valueOf(2))'             | 'java.lang.Integer'

        "Map<String, Integer>"               | "[a: 1, b: 2]"                            | "[a:1, b:2]"
        "HashMap<String, Integer>"           | "new HashMap([a: 1, b: 2])"               | "[a:1, b:2]"
        "LinkedHashMap<String, Integer>"     | "new LinkedHashMap([a: 1, b: 2])"         | "[a:1, b:2]"
        "TreeMap<String, Integer>"           | "new TreeMap([a: 1, b: 2])"               | "[a:1, b:2]"

            }
        }
    }

    static class TestSupplierWithInvalidAttributes extends TestSupplier {
        final static Attribute<Integer> INVALID_ATTRIBUTE1 = Attribute.of("integer", Integer)
        final static Attribute<Long> INVALID_ATTRIBUTE2 = Attribute.of("long", Long)

        @Override
        void execute(ComponentMetadataSupplierDetails details) {

    doLast {
        custom.prop.set(123)
    }
}

task wrongPropertyTypeDsl {
    doLast {
        custom.prop = objects.property(Integer)
    }
}

task wrongPropertyTypeApi {
    doLast {
        custom.prop.set(objects.property(Integer))
    }
}

task wrongRuntimeType {
    doLast {
        custom.prop = providers.provider { 123 }
        custom.prop.get()
    }
}

                        T get();
                    }

                    private SerializableSupplier<Integer> serializableSupplier;
                    private NonSerializableSupplier<Integer> nonSerializableSupplier;

                    public void setSerializableSupplier(SerializableSupplier<Integer> supplier) {
                        this.serializableSupplier = supplier;
                    }

//
// Converting a Pointer to a uintptr produces the memory address of the value
// pointed at, as an integer. The usual use for such a uintptr is to print it.
//
// Conversion of a uintptr back to Pointer is not valid in general.
//
// A uintptr is an integer, not a reference.
// Converting a Pointer to a uintptr creates an integer value
// with no pointer semantics.
// Even if a uintptr holds the address of some object,