# imports
import pytest  # used for our unit tests
from sentry_sdk.utils import AnnotatedValue

# unit tests

def test_basic_creation():
    # Test that removed_because_raw_data returns an AnnotatedValue instance
    av = AnnotatedValue.removed_because_raw_data()
    assert isinstance(av, AnnotatedValue)
    # Verify that the value is an empty string
    assert av.value == ""
    # Verify that the metadata contains the correct remark
    assert av.metadata == {"rem": [["!raw", "x"]]}

def test_equality_with_identical_instances():
    # Create two instances using removed_because_raw_data and check they are equal
    av1 = AnnotatedValue.removed_because_raw_data()
    av2 = AnnotatedValue.removed_because_raw_data()
    assert av1 == av2

def test_equality_with_different_instances():
    # Create an instance using removed_because_raw_data and another with different values and metadata
    av1 = AnnotatedValue.removed_because_raw_data()
    av2 = AnnotatedValue(value="different", metadata={"rem": [["!raw", "y"]]})
    assert av1 != av2

def test_equality_with_non_annotatedvalue_object():
    # Compare an AnnotatedValue instance with a non-AnnotatedValue object
    av = AnnotatedValue.removed_because_raw_data()
    assert av != "not an AnnotatedValue"

def test_empty_metadata():
    # Create an AnnotatedValue instance with an empty metadata dictionary
    av1 = AnnotatedValue.removed_because_raw_data()
    av2 = AnnotatedValue(value="", metadata={})
    assert av1 != av2

def test_null_value():
    # Create an AnnotatedValue instance with None as the value
    av1 = AnnotatedValue.removed_because_raw_data()
    av2 = AnnotatedValue(value=None, metadata={"rem": [["!raw", "x"]]})
    assert av1 != av2

def test_performance_with_large_metadata():
    # Create an AnnotatedValue instance with a very large metadata dictionary
    large_metadata = {"rem": [["!raw", "x"]] * 10000}
    av = AnnotatedValue(value="", metadata=large_metadata)
    assert av.metadata == large_metadata

def test_batch_creation():
    # Create a large number of AnnotatedValue instances using removed_because_raw_data in a loop
    instances = [AnnotatedValue.removed_because_raw_data() for _ in range(10000)]
    assert all(isinstance(av, AnnotatedValue) for av in instances)

def test_integration_with_other_components():
    # Use AnnotatedValue instances created by removed_because_raw_data in a larger system or pipeline
    av = AnnotatedValue.removed_because_raw_data()
    # Example integration: passing to a function that expects AnnotatedValue
    def process_annotated_value(av_instance):
        assert isinstance(av_instance, AnnotatedValue)
    process_annotated_value(av)

def test_serialization_deserialization():
    # Serialize an AnnotatedValue instance to JSON and deserialize it back
    import json
    av = AnnotatedValue.removed_because_raw_data()
    av_json = json.dumps({"value": av.value, "metadata": av.metadata})
    av_dict = json.loads(av_json)
    av_deserialized = AnnotatedValue(value=av_dict["value"], metadata=av_dict["metadata"])
    assert av == av_deserialized

def test_multiple_remarks():
    # Create an AnnotatedValue instance with multiple remarks in the metadata
    av1 = AnnotatedValue.removed_because_raw_data()
    av2 = AnnotatedValue(value="", metadata={"rem": [["!raw", "x"], ["!other", "y"]]})
    assert av1 != av2

def test_complex_metadata_structures():
    # Create an AnnotatedValue instance with nested dictionaries and lists in the metadata
    complex_metadata = {"rem": [["!raw", "x"]], "nested": {"key": ["value1", "value2"]}}
    av = AnnotatedValue(value="", metadata=complex_metadata)
    assert av.metadata == complex_metadata

def test_consistent_outputs():
    # Call removed_because_raw_data multiple times and ensure each call returns an identical AnnotatedValue instance
    av1 = AnnotatedValue.removed_because_raw_data()
    av2 = AnnotatedValue.removed_because_raw_data()
    assert av1 == av2

def test_no_side_effects():
    # Ensure that calling removed_because_raw_data does not modify any global state or input arguments
    global_state = {"key": "value"}
    AnnotatedValue.removed_because_raw_data()
    assert global_state == {"key": "value"}

def test_metadata_key_absence():
    # Test behavior when the metadata dictionary does not contain the "rem" key
    av = AnnotatedValue(value="", metadata={"other_key": "value"})
    assert av.metadata != {"rem": [["!raw", "x"]]}

def test_invalid_metadata_types():
    # Test behavior when the metadata contains values that are not lists or strings
    av = AnnotatedValue(value="", metadata={"rem": "!raw"})
    assert av.metadata != {"rem": [["!raw", "x"]]}