def test_badges_diff():
    cache = {revision_entity_doc: ALAN_TURING,
             parent_entity_doc: ALAN_TURING_OLD}

    badges_diff = solve(diff.datasources.badges_diff, cache=cache)
    assert badges_diff.added == {
        'lawiki',
        'aswiki',
        'enwiki',
        'ruwiki',
        'azwiki'}
    assert badges_diff.removed == set()
    assert badges_diff.intersection == set()
    assert badges_diff.changed == set()
    assert badges_diff.unchanged == set()

    assert (pickle.loads(pickle.dumps(diff.datasources.badges_diff)) ==
            diff.datasources.badges_diff)

    assert solve(diff.badges_added, cache=cache) == 5
    assert solve(diff.badges_removed, cache=cache) == 0
    assert solve(diff.badges_changed, cache=cache) == 0

    assert pickle.loads(pickle.dumps(diff.badges_added)) == diff.badges_added
    assert pickle.loads(pickle.dumps(diff.badges_removed)
                        ) == diff.badges_removed
    assert pickle.loads(pickle.dumps(diff.badges_changed)
                        ) == diff.badges_changed

def test_dict_values():
    cache = {my_dict: {"foo": 1, "bar": 2}}
    assert set(solve(my_values, cache=cache)) == {1, 2}
    cache = {my_dict: None}
    assert set(solve(my_values, cache=cache)) == set()

    assert pickle.loads(pickle.dumps(my_values)) == my_values

def test_content():

    cache = {r_text: "This is some text.\n" +
             "== A heading! ==\n" +
             "{{Foo}} the [[bar]]!"}
    assert (solve(revision.datasources.content, cache=cache) ==
            "This is some text.\n" +
            " A heading! \n" +
            " the bar!")

    assert solve(revision.content_chars, cache=cache) == 41

    assert (pickle.loads(pickle.dumps(revision.content_chars)) ==
            revision.content_chars)

    test_data = """
        Playing games has always been thought to be
        important to the development of well-balanced and creative children;
        however, what part, if any, they should play in the lives of adults
        has never been researched that deeply. I believe that playing games
        is every bit as important for adults as for children. Not only is
        taking time out to play games with our children and other adults
        valuable to building interpersonal relationships but is also a
        wonderful way to release built up tension."""
    cache = {r_text: test_data}
    assert solve(revision.flesh_kincaid, cache=cache) == 52.23
    assert (pickle.loads(pickle.dumps(revision.flesh_kincaid)) ==
            revision.flesh_kincaid)

def test_dict_keys():
    cache = {my_dict: {"foo": 1, "bar": 2}}
    assert set(solve(my_keys, cache=cache)) == {"foo", "bar"}
    cache = {my_dict: None}
    assert set(solve(my_keys, cache=cache)) == set()

    assert pickle.loads(pickle.dumps(my_keys)) == my_keys

def test_text_extractor():
    cache = {text: "This is some text foo bar nope bar foo"}
    assert solve(text_extractor, cache=cache) == ["foo bar", "bar foo"]
    cache = {text: None}
    assert solve(text_extractor, cache=cache) == []

    assert pickle.loads(pickle.dumps(text_extractor)) == text_extractor

def test_feature():
    f = Feature("f")

    assert pickle.loads(pickle.dumps(f)) == f
    assert solve(f, cache={f: 5}) == 5
    assert solve(f, cache={"feature.f": 5}) == 5

    check_feature(five, 5)

def check_feature(feature, expected):

    assert isinstance(expected, feature.returns)

    assert hash(pickle.loads(pickle.dumps(feature))) == hash(feature)

    assert solve(feature) == expected
    assert solve(pickle.loads(pickle.dumps(feature))) == expected

def test_uppercase_words():
    assert (solve(revision.datasources.uppercase_words, cache={r_text: text}) ==
            ['TNT'])
    assert (pickle.loads(pickle.dumps(revision.uppercase_words)) ==
            revision.uppercase_words)
    assert (solve(revision.datasources.uppercase_word_frequency,
                  cache={r_text: text}) ==
            {'TNT': 1})

def test_punctuations():
    assert (solve(revision.datasources.punctuations, cache={r_text: text}) ==
            ['.', '.', ':', '。', '.', '?', '.'])
    assert (pickle.loads(pickle.dumps(revision.punctuations)) ==
            revision.punctuations)
    assert (solve(revision.datasources.punctuation_frequency,
                  cache={r_text: text}) ==
            {'.': 4, ':': 1, '?': 1, '。': 1})

def test_page_namespace_id_in_set():
    wikipedia_namespace = revision.page.namespace.id_in_set({4, 5})
    assert (solve(wikipedia_namespace,
                  cache={revision.datasources.page.namespace.id: 5}) is
            True)
    assert (solve(wikipedia_namespace,
                  cache={revision.datasources.page.namespace.id: 0}) is
            False)

def test_item_in_set():
    is_a_sysop = bools.item_in_set('sysop', my_set)

    assert solve(is_a_sysop, cache={my_set: {'foo', 'bar'}}) is False
    assert solve(is_a_sysop, cache={my_set: {'foo', 'sysop'}}) is True
    assert solve(is_a_sysop, cache={my_set: None}) is False

    assert pickle.loads(pickle.dumps(is_a_sysop)) == is_a_sysop

def test_log():
    log_five = modifiers.log(5)

    assert solve(log_five) == math_log(5)

    assert solve(pickle.loads(pickle.dumps(log_five))) == math_log(5)

    assert repr(log_five) == "<feature.log(5)>"

def test_set_contains_item():
    is_me = bools.set_contains_item({6877667}, my_item)

    assert solve(is_me, cache={my_item: 999}) is False
    assert solve(is_me, cache={my_item: 6877667}) is True
    assert solve(is_me, cache={my_item: None}) is False

    assert pickle.loads(pickle.dumps(is_me)) == is_me

def test_has_property_value():
    assert solve(has_p106_q82594, cache={r_text: ALAN_TEXT})
    assert not solve(has_p106_test, cache={r_text: ALAN_TEXT})
    assert not solve(has_p999_foo, cache={r_text: ALAN_TEXT})

    assert pickle.loads(pickle.dumps(has_p106_q82594)) == has_p106_q82594
    assert pickle.loads(pickle.dumps(has_p106_test)) == has_p106_test
    assert pickle.loads(pickle.dumps(has_p999_foo)) == has_p999_foo

def test_sets_intersect():
    has_small_odd = bools.sets_intersect({1, 2, 3, 5, 7, 9, 11, 13}, my_set)

    assert solve(has_small_odd, cache={my_set: {4, 18, 10}}) is False
    assert solve(has_small_odd, cache={my_set: {20, 10, 3, 5, 1}}) is True
    assert solve(has_small_odd, cache={my_set: None}) is False

    assert pickle.loads(pickle.dumps(has_small_odd)) == has_small_odd

def test_name_namespace_name_matches():
    starts_with_t = revision.page.namespace.name_matches(r"^t")
    assert (solve(starts_with_t,
                  cache={revision.datasources.page.namespace.name: "This"}) is
            True)
    assert (solve(starts_with_t,
                  cache={revision.datasources.page.namespace.name: "Foo"}) is
            False)

def test_max():

    max_five_six_seven = modifiers.max(5, 6, 7)

    assert solve(max_five_six_seven) == 7

    assert solve(pickle.loads(pickle.dumps(max_five_six_seven))) == 7

    assert repr(max_five_six_seven) == "<feature.max(5, 6, 7)>"

def test_stopwords():
    cache = {r_text: "im Lager oder in der Verbannung."}
    assert (solve(german.stopwords.revision.datasources.stopwords, cache=cache) ==
            ["im", "oder", "in", "der"])
    assert (solve(german.stopwords.revision.datasources.non_stopwords,
                  cache=cache) ==
            ["Lager", "Verbannung"])

    assert german.stopwords == pickle.loads(pickle.dumps(german.stopwords))

def test_dictionary():
    cache = {r_text: "Hinzu kamen rund sechs m80 Personen."}
    assert (solve(german.dictionary.revision.datasources.dict_words, cache=cache) ==
            ["Hinzu", "kamen", "rund", "sechs", "Personen"])
    assert (solve(german.dictionary.revision.datasources.non_dict_words,
                  cache=cache) ==
            ["m80"])

    assert german.dictionary == pickle.loads(pickle.dumps(german.dictionary))

def test_stopwords():
    cache = {r_text: "hercegovine jakiel kroz postojanje."}
    assert (solve(bosnian.stopwords.revision.datasources.stopwords, cache=cache) ==
            ["hercegovine", "jakiel", "kroz"])
    assert (solve(bosnian.stopwords.revision.datasources.non_stopwords,
                  cache=cache) ==
            ["postojanje"])

    assert bosnian.stopwords == pickle.loads(pickle.dumps(bosnian.stopwords))