How to use the pebble.thread.Pool function in Pebble

def test_thread_pool_multiple_tasks(self):
        """Thread Pool multiple tasks."""
        tasks = []
        with thread.Pool() as pool:
            for index in range(5):
                tasks.append(pool.schedule(function, args=[1]))
        self.assertEqual(sum([t.get() for t in tasks]), 5)

def test_thread_pool_broken_initializer(self):
        """Thread Pool broken initializer is notified."""
        with self.assertRaises(PoolError):
            with thread.Pool(initializer=broken_initializer) as pool:
                pool.schedule(function)

def test_thread_pool_different_thread(self):
        """Thread Pool multiple tasks are handled by different threades."""
        tasks = []
        with thread.Pool(workers=2) as pool:
            for i in range(0, 5):
                tasks.append(pool.schedule(tid_function))
        self.assertEqual(len(set([t.get() for t in tasks])), 2)

def test_thread_pool_join_running(self):
        """Thread Pool RuntimeError is raised if active pool joined."""
        with thread.Pool() as pool:
            pool.schedule(function, args=[1])
            self.assertRaises(RuntimeError, pool.join)

def test_thread_pool_stopped(self):
        """Thread Pool is not active once stopped."""
        with thread.Pool() as pool:
            pool.schedule(function, args=[1])
        self.assertFalse(pool.active)

def test_thread_pool_stop_tasks(self):
        """Thread Pool not all tasks are performed on stop."""
        tasks = []
        pool = thread.Pool()
        for index in range(10):
            tasks.append(pool.schedule(long_function, args=[index]))
        pool.stop()
        pool.join()
        self.assertTrue(len([t for t in tasks if not t.ready]) > 0)

def test_thread_pool_join_workers(self):
        """Thread Pool no worker is running after join."""
        pool = thread.Pool(workers=4)
        pool.schedule(function, args=[1])
        pool.stop()
        pool.join()
        self.assertEqual(len(pool._pool_manager.workers), 0)

def test_thread_pool_close_tasks(self):
        """Thread Pool all tasks are performed on close."""
        tasks = []
        pool = thread.Pool()
        for index in range(10):
            tasks.append(pool.schedule(function, args=[index]))
        pool.close()
        pool.join()
        map(self.assertTrue, [t.ready for t in tasks])

def test_thread_pool_error(self):
        """Thread Pool errors are raised by task get."""
        with thread.Pool() as pool:
            task = pool.schedule(error_function)
        self.assertRaises(Exception, task.get)

def test_thread_pool_single_task(self):
        """Thread Pool single task."""
        with thread.Pool() as pool:
            task = pool.schedule(function, args=[1],
                                 kwargs={'keyword_argument': 1})
        self.assertEqual(task.get(), 2)