asyncgui/modified_testcases/test_ExclusiveEvent.py

import unittest
import pytest
from main import ExclusiveEvent, InvalidStateError, TaskState
import asyncgui as ag  # Assuming asyncgui still needs to be imported

class TestExclusiveEvent(unittest.TestCase):

    def test_wait_fire_wait(self):
        async def async_fn():
            args, kwargs = await e.wait()
            self.assertEqual(args, (1,))
            self.assertEqual(kwargs, {'one': 'ONE'})

        e = ExclusiveEvent()
        task = ag.start(async_fn())
        self.assertFalse(task.finished)
        e.fire(1, one='ONE')
        self.assertTrue(task.finished)

    def test_fire_wait_fire(self):
        async def async_fn():
            args, kwargs = await e.wait()
            self.assertEqual(args, (2,))
            self.assertEqual(kwargs, {'two': 'TWO'})

        e = ExclusiveEvent()
        e.fire(1, one='ONE')
        task = ag.start(async_fn())
        self.assertFalse(task.finished)
        e.fire(2, two='TWO')
        self.assertTrue(task.finished)

    def test_fire_fire(self):
        e = ExclusiveEvent()
        e.fire(None)
        e.fire(None)

    def test_wait_wait(self):
        e = ExclusiveEvent()
        ag.start(e.wait())
        with self.assertRaises(InvalidStateError):
            ag.start(e.wait())

    def test_cancel(self):
        async def async_fn(ctx):
            async with ag.open_cancel_scope() as scope:
                ctx['scope'] = scope
                await e.wait()
                pytest.fail()
            await ag.sleep_forever()

        ctx = {}
        e = ExclusiveEvent()
        task = ag.start(async_fn(ctx))
        self.assertEqual(task.state, TaskState.STARTED)
        ctx['scope'].cancel()
        self.assertEqual(task.state, TaskState.STARTED)
        e.fire(None, python='awesome')
        self.assertEqual(task.state, TaskState.STARTED)
        task._step()
        self.assertEqual(task.state, TaskState.FINISHED)


if __name__ == '__main__':
    unittest.main()