tartley.com

I’ve been trying to create a simple acceptance test for a Pyglet application. A thorough suite of acceptance tests, verifying the correctness of all the shapes drawn to the screen by OpenGL, sounds like far more work than I want to do. But a couple of simple acceptance tests would be valuable, to check out basic things: that the application runs; opens a fullscreen window; responds correctly to some basic inputs and command-line options; and has an acceptable framerate. Especially if I could quickly run this basic smoke test on multiple operating systems.

I tried writing an acceptance test which ran the application-under-test on a new thread. This didn’t work for me *at all*, so for the time being I’d given up, and was proceeding without acceptance-level tests.

A couple of days ago I had the idea of a test that didn’t involve threading. Instead, it takes a list of test conditions (as lambdas), and uses Pyglet’s own clock and scheduler to request a callback to a test function - try_condition() - on every frame.

from unittest import TestCase
from pyglet import app, clock

class AcceptanceTest(TestCase):

    timeout = 1.0

    def set_conditions(self, conditions):
        self.conditions = conditions
        self.next_condition()
        clock.schedule(lambda dt: self.try_condition(dt))

So self.conditions is the list of lambdas that will be provided by the acceptance test. Calling self.next_condition() merely plucks the next condition off the list, into self.condition. If there are no more conditions left, then the test has entirely passed and it requests the application to terminate, by setting the Pyglet member window.has_exit to True.

    def next_condition(self):
        if len(self.conditions) > 0:
            self.condition = self.conditions.pop(0)
            self.time = 0.0
        else:
            self.terminate()

    def terminate(self):
        win = self.get_window()
        win.has_exit = True

    def get_window(self):
        windows = self.get_windows()
        if len(windows) == 1:
            return windows[0]
        return None

    def get_windows(self):
        return [w for w in app.windows]

When try_condition() gets called by Pyglet on the first frame, it evaluates the value of self.condition. If True, then that first part of the test has passed, and it gets the next condition off the list. If False, then this function simply returns, to let the application continue running. When try_condition() is called again on the next frame, it resumes where it left off, testing out the false condition again. After it has been trying the same condition for a long enough time, it deems that condition to have failed, and raises an assertion error.

    def try_condition(self, dt):
        if self.condition():
            self.next_condition()
        else:
            self.time += dt
            if self.time > self.timeout:
                self.fail("timeout on %s" % self.condition)

In future, I should probably allow the acceptance test code to specify a different timeout value for each condition.

Anyhow, we can then write an acceptance test by inheriting from this AcceptanceTest class, providing an appropriate list of conditions, and then just calling the application’s main() function. This function won’t return until the application exits, either when one of the conditions times out and raises an assertion error, or else when all conditions have passed and the test framework sets window.has_exit.

from testutils.testcase import run_test
from acceptance_test import AcceptanceTest
from sole_scion import main

class AT001_app_opens_a_fullscreen_window(AcceptanceTest):

    def is_window_visible(self):
        win = self.get_window()
        return win and win.visible

    def is_window_fullscreen(self):
        win = self.get_window()
        return win and win.fullscreen

    def test_window(self):
        conditions = [
            self.is_window_visible,
            self.is_window_fullscreen,
        ]
        self.set_conditions(conditions)
        main()

if __name__ == “__main__”:
    run_test()

The conditions don’t simply have to be expressions to verify the application state. They could stimulate the application by raising mouse or keyboard events, etc, and then simply return True so that the test harness would move right on to the next condition.

Early days with this idea, but it seems to work great, and thus far I’m very happy with it.

by Bob Walsh

Finally got around to plucking this off the shelf, and yes it’s an interesting grab-bag of things to think about, and case studies of people who have taken the plunge. But there’s not very much in here that’s significantly unexpected. The chapter about business formalities says ‘yes you should create a business plan’, but has no guidance about how to go about that.

All in all then, a nice checklist to make sure you’re not overlooking anything too obvious, but it didn’t feel like the in-depth detail I was hoping for.

Rating: 6/10

Everyone today is abuzz with the ‘release early, release often’ sentiment, so I’ve decided to get in the spirit and upload the first iteration of ‘Sole Scion’, my summertime sabbatical game project.

Version 0.1 merely bounces some circles off an inclined plane (pictured.) I aim to transform this into a 2D graphical adventure game, in which I hope emergent fun will take place, once I populate the world with enough twisty corridors, uniquely-shaped objects that need slotting into the right places, and judicious instances of ornery fauna to contend with.

It’s written in Python, using Chipmunk for rigid body Newtonian dynamics, with Python bindings using Pymunk. Rendering, gameloop, sounds, etc are handled by Pyglet.

Sole Scion is hosted on Google Code, with Subversion read-access and a source code tarball, including the redistributables for the above dependencies, should anyone be curious. It has a New BSD License.

Feedback, thoughts and ideas, very welcome.

Update: I’ve only run it on Linux, but reportedly it also works on Windows. Thanks Xtian!

Update: It also reportedly works under PyPy, provided you install the ‘functools’ module. Thanks Maciej!

It never gets old. Thank you for the giggles, Video Game Freedom.

Carl G. Jung (Author),
Joseph Campbell (Editor),
R. F. C. Hull (Translator)

I didn’t quite know what to make of Jung when KT first handed me this collection of his essays, many moons ago. Some sort of 19th-century lunatic Freudian psycho-analyst who was a dab hand with a ouija board and sang the praises of ritual sacrifices to the almighty triple-headed hermaphrodite goddesses, right? Something like that.

So it was good to discover that Dr. Jung isn’t the wild-eyed loon that I’d written him off as. His attitude is entirely credible and scientific, and while he may invoke triple-headed hermaphrodite goddesses, he does so in an entirely respectable and deeply pertinent way.

His essays are prefaced by a short biography to set the works in a meaningful social and personal context. Of particular entertainment value is the ongoing deterioration of his relationship with Freud, and the corresponding divergence of their theories. This culminated in Freud’s desperate plea for Jung’s cooperation in ensuring that ‘the sexual theory’ be established as an unchallengeable axiom in the explanation of all human behaviours. This didn’t strike Jung as being particularly scientific, and obviously speaks volumes about Freud - lifelong adulterer - as both a person and a theorist.

Of the essays themselves, some of them resonated more for me than others. I very much liked his explanation of the nature of the subconscious necessarily being the polar opposite to the conscious ego, since all perceptions which do not fit in with the beliefs or attitudes of the conscious mind are dismissed and repressed. This is a natural and normal reaction, and it helps us to maintain a consistent and useful world-view. However, those repressed memories are not erased - they are simply being ignored by the concious mind. The subconscious appears to have unfettered access to these repressed fragments. In situations where the conciousness exercises wilful determination, this leads to a stressful state of cognitive dissonance, in which the subconscious comprises a roiling mass of all the impressions and emotions that the concious mind has rejected. Hence, the tenancy for people to maintain a strident outward appearance which is completely at odds with, and arguably exacerbates, pent-up inner demons. For some reason, the examples that spring to my mind are priests molesting altar boys, or maybe catholic schoolgirls. Not sure if that’s a reflection of modern organised religion or my own state of mind, oh well.

Equally interesting is Jung’s theory of the collective unconscious - that the religions, myths and legends of the world are united by a handful of common themes, or archetypes, not because of cross-pollination of ideas, but because these themes are an expression of psychological commonalities between all human minds - seems credible and useful. I still have some reservation in accepting Jung’s particular menagerie of archetypes as definitive. He may have distilled them from many years studying the world’s religions and mythologies, but if you throw enough noise at a filter the result ends up being characteristic of the filter (ie. Jung himself) rather than the noise. However, the validity of the idea in general, and of some of fundamental archetypes, seems unarguable.

He carefully avoids any explicit judgement of whether any religions or myths have any basis in objective reality. Such judgements, he rightly notes, are beyond the ability of the scientific method to evaluate. However, he provides the potential to categorise them all as simply being phenomena of human psychology - ie. they are entirely in our head. This is a double-edge sword, however, for this seeming dismissal rebounds poetically upon us. What were once distant and faintly heard mythologies, are now given a deep and highly personal significance, as they are nothing less than the worldy manifestations of the innermost workings of our own minds, which each of us would fail to heed at our peril.

There are other sections which I didn’t find so compelling, such as his concept of synchronicity, but overall it was thoroughly enjoyable and insightful.

Rating: 8/10

I *should* be searching out and evaluating Python geometry libraries. But I keep getting these niggling impulses to start hammering out my own vector, polygon and quaternion classes. Possibly in C. Ohdear.

Why is it so much easier, or at least so much more appealing, to start beavering away on your own code, rather than to take the sensible approach of evaluating existing libraries? A couple of hours searching could save you days, weeks or months of work, and libraries written and used by several people will undoubtedly be of higher quality as well - it should be a no-brainer.

It’s easy enough to conjure up subjective justifications for it on a personal level, but to my mind they rarely hold up to scrutiny. Reading and understanding other people’s code is said to be harder than churning out some according to your own vision, but surely the depth of understanding required to use a module should surely be substantially less than it would take to write it? Likewise, curiosity, obsessiveness, a sense of personal achievement play a part, but these motives are deeply subjective, and cannot be used to argue the case that ‘rolling your own’ is an efficient or rational decision, merely an enjoyable (or compulsive) one. Expectations of quality also contribute - everyone thinks that their own code is better. But this is rarely really the case, and experienced practitioners recognise it.

On a deeper level, then, why does some part of us allow these inadequate justifications to hold sway? Even if rationally, we know it doesn’t make sense, why does it feel so desirable? What I’m really asking is, why have we been evolved to want to build our own, even though it is so clearly the wrong thing to do?

What if we are tuned, as individuals, to prematurely settle on our own idiosyncratic approach? The net result would be that, for any given problem, a flurry of individuals would each set out in different directions, regardless of what results others might have already achieved. Viewed as a group activity, this starts to sound a little saner. Such a dispersion of individuals would rapidly and thoroughly explore all the corners of the problem space. Compared to the situation where we all just build cumulatively on what everyone else has done before, the chances of any one individual finding an optimal answer is low, but the chances of someone in the group finding it is greatly increased.

It’s a survival-of-the-group trait, that each of us is evolved to pick a wrong-looking answer, and then expend ourselves beavering away to prove it. Oh dear indeed.

I haven’t really stopped reading everyone else’s posts. Cold turkey? God, you’re a bunch of douchebags.