Beispiel #1
0
def test_generate_configurations_web_example():
    ps = ParameterSet.create_from_value_sizes([3, 8, 2, 2])
    gen = RecursiveGenerator(ps, 2)
    cs = gen.generate_covering_array()

    cs_expected = np.array([
        [1, 1, 1, 1],
        [1, 2, 2, 2],
        [1, 3, 0, 0],
        [2, 1, 2, 0],
        [2, 2, 0, 1],
        [2, 3, 1, 2],
        [3, 1, 0, 2],
        [3, 2, 1, 0],
        [3, 3, 2, 1],
        [1, 4, 1, 1],
        [2, 4, 2, 2],
        [3, 4, 0, 0],
        [1, 5, 1, 1],
        [2, 5, 2, 2],
        [3, 5, 0, 0],
        [1, 6, 1, 1],
        [2, 6, 2, 2],
        [3, 6, 0, 0],
        [1, 7, 1, 1],
        [2, 7, 2, 2],
        [3, 7, 0, 0],
        [1, 8, 1, 1],
        [2, 8, 2, 2],
        [3, 8, 0, 0],
    ],
                           dtype=DEFAULT_NDARRAY_TYPE)

    assert np.array_equal(cs, cs_expected)
Beispiel #2
0
def test_do_horizontal_growth_2():
    ps = ParameterSet.create_from_value_sizes([2, 2, 5])
    g = IpoGenerator(ps, 2)
    g.first_parameters()
    actual = g.do_horizontal_growth(2)

    assert len(actual) == 12
    ie1 = InteractionElement({1: 1, 2: 5})
    ie2 = InteractionElement({1: 2, 2: 5})
    ie3 = InteractionElement({0: 1, 2: 5})
    ie4 = InteractionElement({0: 2, 2: 1})
    ie5 = InteractionElement({0: 2, 2: 2})
    ie6 = InteractionElement({1: 1, 2: 2})
    ie7 = InteractionElement({0: 2, 2: 5})
    ie8 = InteractionElement({1: 2, 2: 1})
    ie9 = InteractionElement({0: 1, 2: 3})
    ie10 = InteractionElement({1: 2, 2: 3})
    ie11 = InteractionElement({0: 1, 2: 4})
    ie12 = InteractionElement({1: 1, 2: 4})
    assert ie1 in actual
    assert ie2 in actual
    assert ie3 in actual
    assert ie4 in actual
    assert ie5 in actual
    assert ie6 in actual
    assert ie7 in actual
    assert ie8 in actual
    assert ie9 in actual
    assert ie10 in actual
    assert ie11 in actual
    assert ie12 in actual
Beispiel #3
0
def test_generate_configurations4():
    ps = ParameterSet.create_from_value_sizes([2, 3, 2])
    gen = RecursiveGenerator(ps, 2)
    cs = gen.generate_covering_array()

    cs_expected = np.array([
        [1, 1, 1],
        [1, 2, 2],
        [2, 1, 2],
        [2, 2, 1],
        [1, 3, 1],
        [2, 3, 2],
    ],
                           dtype=DEFAULT_NDARRAY_TYPE)

    assert np.array_equal(cs, cs_expected)
Beispiel #4
0
def test_pairs_covered_in_2():
    ps = ParameterSet.create_from_value_sizes([2, 2, 3, 2])
    g = IpoGenerator(ps, 2)

    cs = np.array([[1, 2, 3]], dtype=DEFAULT_NDARRAY_TYPE)
    g.test_set = cs

    ie1 = InteractionElement({2: 3, 3: 1})
    ie2 = InteractionElement({0: 2, 3: 1})
    ie3 = InteractionElement({1: 1, 3: 1})

    s = {ie1, ie2, ie3}

    s2 = g.pairs_covered_in(s, 0, 3, 1)

    assert len(s2) == 1
    assert ie1 in s2
Beispiel #5
0
def test_generate_configurations11():
    ps = ParameterSet.create_from_value_sizes([6, 6, 8, 6])
    gen = RecursiveGenerator(ps, 2)
    cs = gen.generate_covering_array()

    cs_expected = np.array([
        [1, 1, 1, 1],
        [2, 2, 2, 2],
        [3, 3, 3, 3],
        [4, 4, 4, 4],
        [5, 5, 5, 5],
        [6, 6, 6, 6],
        [0, 0, 7, 0],
        [4, 5, 6, 0],
        [5, 6, 7, 1],
        [6, 0, 1, 2],
        [0, 1, 2, 3],
        [1, 2, 3, 4],
        [2, 3, 4, 5],
        [3, 4, 5, 6],
        [0, 2, 4, 6],
        [1, 3, 5, 0],
        [2, 4, 6, 1],
        [3, 5, 7, 2],
        [4, 6, 1, 3],
        [5, 0, 2, 4],
        [6, 1, 3, 5],
        [3, 6, 2, 5],
        [4, 0, 3, 6],
        [5, 1, 4, 0],
        [6, 2, 5, 1],
        [0, 3, 6, 2],
        [1, 4, 7, 3],
        [2, 5, 1, 4],
        [6, 3, 7, 4],
        [0, 4, 1, 5],
        [1, 5, 2, 6],
        [2, 6, 3, 0],
        [3, 0, 4, 1],
        [4, 1, 5, 2],
        [5, 2, 6, 3],
        [2, 0, 5, 3],
        [3, 1, 6, 4],
        [4, 2, 7, 5],
        [5, 3, 1, 6],
        [6, 4, 2, 0],
        [0, 5, 3, 1],
        [1, 6, 4, 2],
        [5, 4, 3, 2],
        [6, 5, 4, 3],
        [0, 6, 5, 4],
        [1, 0, 6, 5],
        [2, 1, 7, 6],
        [3, 2, 1, 0],
        [4, 3, 2, 1],
        [1, 1, 8, 1],
        [2, 2, 8, 2],
        [3, 3, 8, 3],
        [4, 4, 8, 4],
        [5, 5, 8, 5],
        [6, 6, 8, 6],
    ],
                           dtype=DEFAULT_NDARRAY_TYPE)

    assert np.array_equal(cs, cs_expected)