async def main():
from_ch, to_ch = chan(), chan(1)
m = c.mix(to_ch)
m.admix(from_ch)
from_ch.close()
await asyncio.sleep(0.1)
self.assertIs(await to_ch.put('success'), True)
async def main():
to_ch = chan(1)
solo_ch1, solo_ch2, non_solo_ch = chan(1), chan(1), chan(1)
m = c.mix(to_ch)
m.solo_mode('pause')
m.toggle({
solo_ch1: {
'solo': True
},
solo_ch2: {
'solo': True
},
non_solo_ch: {}
})
await solo_ch1.put('solo_ch1 not paused')
self.assertEqual(await to_ch.get(), 'solo_ch1 not paused')
await solo_ch2.put('solo_ch2 not paused')
self.assertEqual(await to_ch.get(), 'solo_ch2 not paused')
await non_solo_ch.put('stay in non_solo_ch')
await asyncio.sleep(0.1)
self.assertEqual(await non_solo_ch.get(), 'stay in non_solo_ch')
m.toggle({solo_ch1: {'solo': False}, solo_ch2: {'solo': False}})
await asyncio.sleep(0.1)
await solo_ch1.put('solo_ch1 still not paused')
self.assertEqual(await to_ch.get(), 'solo_ch1 still not paused')
await solo_ch2.put('solo_ch2 still not paused')
self.assertEqual(await to_ch.get(), 'solo_ch2 still not paused')
await non_solo_ch.put('non_solo_ch not paused')
self.assertEqual(await to_ch.get(), 'non_solo_ch not paused')
async def main():
to_ch, from_ch = chan(), chan(1)
admix_ch, unmix_ch, pause_ch = chan(1), chan(1), chan(1)
m = c.mix(to_ch)
m.toggle({from_ch: {}, unmix_ch: {}})
# Start waiting put to to_ch
await from_ch.put('successful transfer')
await asyncio.sleep(0.1)
# Apply operations while mix is waiting on to_ch
m.admix(admix_ch)
m.unmix(unmix_ch)
m.toggle({pause_ch: {'pause': True}})
# Confirm state is correct
self.assertEqual(await to_ch.get(), 'successful transfer')
await admix_ch.put('admix_ch added')
self.assertEqual(await to_ch.get(), 'admix_ch added')
await unmix_ch.put('unmix_ch removed')
await asyncio.sleep(0.1)
self.assertEqual(await unmix_ch.get(), 'unmix_ch removed')
await pause_ch.put('pause_ch paused')
await asyncio.sleep(0.1)
self.assertEqual(await pause_ch.get(), 'pause_ch paused')
async def main():
unpaused_ch, paused_ch, to_ch = chan(1), chan(1), chan(1)
m = c.mix(to_ch)
m.toggle({
unpaused_ch: {
'pause': False
},
paused_ch: {
'pause': True
}
})
await unpaused_ch.put('not paused')
self.assertEqual(await to_ch.get(), 'not paused')
await paused_ch.put('remain in paused_ch')
await asyncio.sleep(0.1)
self.assertEqual(await paused_ch.get(), 'remain in paused_ch')
m.toggle({
unpaused_ch: {
'pause': True
},
paused_ch: {
'pause': False
}
})
await paused_ch.put('no longer paused')
self.assertEqual(await to_ch.get(), 'no longer paused')
await unpaused_ch.put('paused now')
await asyncio.sleep(0.1)
self.assertEqual(await unpaused_ch.get(), 'paused now')
async def main():
solo_ch1, solo_ch2, non_solo_ch = chan(), chan(), chan()
to_ch = chan(1)
m = c.mix(to_ch)
m.solo_mode('mute')
m.toggle({
solo_ch1: {
'solo': True
},
solo_ch2: {
'solo': True
},
non_solo_ch: {}
})
await solo_ch1.put('solo_ch1 not muted')
self.assertEqual(await to_ch.get(), 'solo_ch1 not muted')
await solo_ch2.put('solo_ch2 not muted')
self.assertEqual(await to_ch.get(), 'solo_ch2 not muted')
await non_solo_ch.put('drop me')
await asyncio.sleep(0.1)
self.assertIsNone(to_ch.poll())
m.toggle({solo_ch1: {'solo': False}, solo_ch2: {'solo': False}})
await asyncio.sleep(0.1)
await solo_ch1.put('solo_ch1 still not muted')
self.assertEqual(await to_ch.get(), 'solo_ch1 still not muted')
await solo_ch2.put('solo_ch2 still not muted')
self.assertEqual(await to_ch.get(), 'solo_ch2 still not muted')
await non_solo_ch.put('non_solo_ch not muted')
self.assertEqual(await to_ch.get(), 'non_solo_ch not muted')
async def main():
from_ch, to_ch = chan(1), chan(1)
m = c.mix(to_ch)
m.toggle({from_ch: {'pause': True, 'mute': True}})
await from_ch.put('stay in from_ch')
await asyncio.sleep(0.1)
self.assertEqual(await from_ch.get(), 'stay in from_ch')
async def main():
from_ch, to_ch = chan(1), chan()
m = c.mix(to_ch)
m.admix(from_ch)
await asyncio.sleep(0.1)
to_ch.close()
await from_ch.put('mix consumes me')
await from_ch.put('mix ignores me')
await asyncio.sleep(0.1)
self.assertEqual(await from_ch.get(), 'mix ignores me')
async def main():
from_ch1, from_ch2, to_ch = chan(), chan(), chan(1)
m = c.mix(to_ch)
m.admix(from_ch1)
await from_ch1.put('from_ch1')
self.assertEqual(await to_ch.get(), 'from_ch1')
m.admix(from_ch2)
await from_ch1.put('from_ch1 again')
self.assertEqual(await to_ch.get(), 'from_ch1 again')
await from_ch2.put('from_ch2')
self.assertEqual(await to_ch.get(), 'from_ch2')
async def main():
ch = chan()
m = c.mix(ch)
with self.assertRaises(ValueError):
m.toggle({'not a channel': {}})
with self.assertRaises(ValueError):
m.toggle({ch: {'invalid option': True}})
with self.assertRaises(ValueError):
m.toggle({ch: {'solo': 'not a boolean'}})
with self.assertRaises(ValueError):
m.toggle({ch: {'pause': 'not a boolean'}})
with self.assertRaises(ValueError):
m.toggle({ch: {'mute': 'not a boolean'}})
async def main():
from_ch1, from_ch2, to_ch = chan(1), chan(1), chan(1)
m = c.mix(to_ch)
m.admix(from_ch1)
await from_ch1.put('from_ch1')
self.assertEqual(await to_ch.get(), 'from_ch1')
m.admix(from_ch2)
m.unmix(from_ch1)
await from_ch2.put('from_ch2')
self.assertEqual(await to_ch.get(), 'from_ch2')
await from_ch1.put('remain in from_ch1')
await asyncio.sleep(0.1)
self.assertIsNone(to_ch.poll())
self.assertEqual(await from_ch1.get(), 'remain in from_ch1')
async def main():
unmuted_ch, muted_ch = chan(), chan()
to_ch = chan(1)
m = c.mix(to_ch)
m.toggle({unmuted_ch: {'mute': False}, muted_ch: {'mute': True}})
await unmuted_ch.put('not muted')
self.assertEqual(await to_ch.get(), 'not muted')
await muted_ch.put('mute me')
self.assertIsNone(to_ch.poll())
m.toggle({unmuted_ch: {'mute': True}, muted_ch: {'mute': False}})
await muted_ch.put('the mute can now talk')
self.assertEqual(await to_ch.get(), 'the mute can now talk')
await unmuted_ch.put('i made a deal with Ursula')
self.assertIsNone(to_ch.poll())
async def main():
from_ch, to_ch = chan(), chan(1)
m = c.mix(to_ch)
m.toggle({from_ch: {'solo': True, 'pause': True, 'mute': True}})
await from_ch.put('success')
self.assertEqual(await to_ch.get(), 'success')
async def main():
m = c.mix(chan())
with self.assertRaises(ValueError):
m.solo_mode('invalid mode')
