Exemple #1
0
def test_defaults(pair: AlternativeNativeListsPair) -> None:
    alternative, native = pair

    alternative_result, native_result = alternative.pop(), native.pop()

    assert alternative_result == native_result
    assert are_alternative_native_lists_equal(alternative, native)
def test_slice(
        pair_with_slice: Tuple[AlternativeNativeListsPair, int]) -> None:
    (alternative, native), slice_ = pair_with_slice

    del alternative[slice_], native[slice_]

    assert are_alternative_native_lists_equal(alternative, native)
def test_index(pair_with_index: Tuple[AlternativeNativeListsPair, int],
               value: Any) -> None:
    (alternative, native), index = pair_with_index

    alternative[index] = native[index] = value

    assert are_alternative_native_lists_equal(alternative, native)
def test_index(
        pair_with_index: Tuple[AlternativeNativeListsPair, int]) -> None:
    (alternative, native), index = pair_with_index

    del alternative[index], native[index]

    assert are_alternative_native_lists_equal(alternative, native)
Exemple #5
0
def test_basic(pair: AlternativeNativeListsPair, values: List[Any]) -> None:
    alternative, native = pair

    alternative += values
    native += values

    assert are_alternative_native_lists_equal(alternative, native)
Exemple #6
0
def test_basic(pair: AlternativeNativeListsPair) -> None:
    alternative, native = pair

    alternative_result, native_result = alternative.reverse(), native.reverse()

    assert alternative_result == native_result
    assert are_alternative_native_lists_equal(alternative, native)
def test_basic(pair: AlternativeNativeListsPair, value: Any) -> None:
    alternative, native = pair

    alternative_result, native_result = (alternative.append(value),
                                         native.append(value))

    assert alternative_result is native_result is None
    assert are_alternative_native_lists_equal(alternative, native)
Exemple #8
0
def test_full(pair_with_index: Tuple[AlternativeNativeListsPair, int]) -> None:
    (alternative, native), index = pair_with_index

    alternative_result, native_result = (alternative.pop(index),
                                         native.pop(index))

    assert alternative_result == native_result
    assert are_alternative_native_lists_equal(alternative, native)
Exemple #9
0
def test_basic(pair: AlternativeNativeListsPair) -> None:
    alternative, native = pair

    alternative_result = alternative.copy()
    native_result = native.copy()

    assert are_alternative_native_lists_equal(alternative_result,
                                              native_result)
Exemple #10
0
def test_basic(pair: AlternativeNativeListsPair, values: List[Any]) -> None:
    alternative, native = pair

    alternative_result, native_result = (alternative.extend(values),
                                         native.extend(values))

    assert alternative_result is native_result is None
    assert are_alternative_native_lists_equal(alternative, native)
def test_slice(
    pair_with_slice_and_values: Tuple[AlternativeNativeListsPair, int,
                                      List[Any]]
) -> None:
    (alternative, native), slice_, values = pair_with_slice_and_values

    alternative[slice_] = native[slice_] = values

    assert are_alternative_native_lists_equal(alternative, native)
Exemple #12
0
def test_basic(
        pair_with_value: Tuple[AlternativeNativeListsPair, Any]) -> None:
    (alternative, native), value = pair_with_value

    alternative_result, native_result = (alternative.remove(value),
                                         native.remove(value))

    assert alternative_result is native_result is None
    assert are_alternative_native_lists_equal(alternative, native)
Exemple #13
0
def test_basic(first_pair: AlternativeNativeListsPair,
               second_pair: AlternativeNativeListsPair) -> None:
    alternative_first, native_first = first_pair
    alternative_second, native_second = second_pair

    alternative_result = alternative_first + alternative_second
    native_result = native_first + native_second

    assert are_alternative_native_lists_equal(alternative_result,
                                              native_result)
def test_basic(objects: List[Any]) -> None:
    alternative, native = AlternativeList(objects), NativeList(objects)

    assert are_alternative_native_lists_equal(alternative, native)
Exemple #15
0
def test_basic(pair: AlternativeNativeListsPair) -> None:
    alternative, native = pair

    assert are_alternative_native_lists_equal(pickle_round_trip(alternative),
                                              pickle_round_trip(native))