# imports
import threading

import pytest  # used for our unit tests
from sentry_sdk._queue import Queue

# unit tests

def test_queue_unlimited_size():
    # Queue with no maximum size (unlimited)
    q = Queue(maxsize=0)
    assert not q.full()  # Should never be full

def test_queue_small_maxsize_full():
    # Queue with a small maximum size, and it is full
    q = Queue(maxsize=3)
    q.queue.extend([1, 2, 3])
    assert q.full()  # Should be full

def test_queue_small_maxsize_not_full():
    # Queue with a small maximum size, and it is not full
    q = Queue(maxsize=3)
    q.queue.extend([1, 2])
    assert not q.full()  # Should not be full

def test_queue_empty_with_positive_maxsize():
    # Empty queue with a positive maximum size
    q = Queue(maxsize=5)
    assert not q.full()  # Should not be full

def test_queue_maxsize_one_full():
    # Queue with maximum size of 1, and it is full
    q = Queue(maxsize=1)
    q.queue.append(1)
    assert q.full()  # Should be full

def test_queue_maxsize_one_not_full():
    # Queue with maximum size of 1, and it is not full
    q = Queue(maxsize=1)
    assert not q.full()  # Should not be full

def test_queue_maxsize_one_then_empty():
    # Queue with maximum size of 1, then remove the item
    q = Queue(maxsize=1)
    q.queue.append(1)
    q.queue.pop()
    assert not q.full()  # Should not be full

def test_queue_maxsize_equal_to_items():
    # Queue with maximum size equal to the number of items
    q = Queue(maxsize=5)
    q.queue.extend([1, 2, 3, 4, 5])
    assert q.full()  # Should be full

def test_concurrent_additions():
    # Concurrent additions to the queue
    q = Queue(maxsize=10)
    def add_items():
        for _ in range(10):
            with q.mutex:
                if len(q.queue) < q.maxsize:
                    q.queue.append(1)

    threads = [threading.Thread(target=add_items) for _ in range(5)]
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
    assert q.full()  # Should be full

def test_concurrent_additions_and_removals():
    # Concurrent additions and removals
    q = Queue(maxsize=10)
    def add_items():
        for _ in range(10):
            with q.mutex:
                if len(q.queue) < q.maxsize:
                    q.queue.append(1)

    def remove_items():
        for _ in range(5):
            with q.mutex:
                if q.queue:
                    q.queue.pop()

    threads = [threading.Thread(target=add_items) for _ in range(5)] + [threading.Thread(target=remove_items) for _ in range(5)]
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
    assert not q.full()  # Should not be full

def test_large_queue_full():
    # Large queue with a large maximum size
    q = Queue(maxsize=10000)
    q.queue.extend(range(10000))
    assert q.full()  # Should be full

def test_large_queue_not_full():
    # Large queue with a large maximum size, but not full
    q = Queue(maxsize=10000)
    q.queue.extend(range(9999))
    assert not q.full()  # Should not be full

def test_stress_test():
    # Stress test with maximum size and large number of operations
    q = Queue(maxsize=1000000)
    for _ in range(1000000):
        with q.mutex:
            if len(q.queue) < q.maxsize:
                q.queue.append(1)
            if len(q.queue) > 0:
                q.queue.pop()
    assert not q.full()  # Should not be full

def test_invalid_maxsize():
    # Queue with invalid maximum size
    with pytest.raises(ValueError):
        Queue(maxsize=-1)

def test_non_integer_maxsize():
    # Queue with non-integer maximum size
    with pytest.raises(TypeError):
        Queue(maxsize='a')

def test_deterministic_behavior():
    # Deterministic behavior across multiple runs
    q = Queue(maxsize=5)
    q.queue.extend([1, 2, 3, 4, 5])
    assert q.full()  # Should be full
    q.queue.pop()
    assert not q.full()  # Should not be full
    q.queue.append(6)
    assert q.full()  # Should be full again