def render(self, template_name, context={}, index=None):
        """
        Given a template name, pick a template and render it with the provided
        context.

        :param template_name: the name of a template group.

        :param context: dictionary representing values to be rendered

        :param index: optional, the specific index in the collection of
            templates

        :raises NotImplementedError: if no template can be found identified by
            template_name

        :return:
        """
        if template_name not in self.templates:
            raise NotImplementedError("Template not found: %s" % template_name)
        template_functions = self.templates.get(template_name)
        if index is None:
            index = random.randrange(len(template_functions))
        else:
            index %= len(template_functions)
        return mustache.render(template_functions[index], context)

	def test(self):
		template = testData['template']
		partials = testData.has_key('partials') and testData['partials'] or {}
		expected = testData['expected']
		data	 = testData['data']

		# Convert code strings to functions.
		new_data = {}
		for key, val in data.iteritems():
			if isinstance(val, dict) and val.get('__tag__') == 'code':
				val = eval(val['python'])
			new_data[key] = val

		actual = render(template, new_data, partials)

		message = """%s

  Template: \"""%s\"""

  Expected: %s
  Actual:   %s

  Expected: \"""%s\"""
  Actual:   \"""%s\"""
  """ % (description, template, repr(expected), repr(actual), expected, actual)

		self.assertEquals(actual, expected, message)

	def test_non_strings(self):
		template = "{{#stats}}({{key}} & {{value}}){{/stats}}"
		stats = []
		stats.append({'key': 123, 'value': ['something']})
		stats.append({'key': u"chris", 'value': 0.900})

		ret = mustache.render(template, { 'stats': stats })
		self.assertEquals(ret, """(123 & ['something'])(chris & 0.9)""")

def render_template(name, context):
    template = open(os.path.join(TEMPLATES_ROOT, name), 'r').read()

    partials = {
        'header': open(os.path.join(TEMPLATES_ROOT, 'header.html')).read(),
        'footer': open(os.path.join(TEMPLATES_ROOT, 'footer.html')).read(),
    }

    return mustache.render(template, context, partials=partials)

 def __spec_test(self, test_suite):
     with open(self.PATH.format(test_suite), 'r') as fp:
         suite = json.loads(fp.read())
     tests = suite['tests']
     for test in tests:
         template = mustache.build(test['template'], test.get('partials'))
         result = mustache.render(template, test['data'])
         msg = '{}: {} != {}'.format(test['desc'], repr(str(test['expected'])), repr(str(result)))
         self.assertEqual(result, test['expected'], msg)

	def test_render_zero(self):
		template = 'My value is {{value}}.'
		ret = mustache.render(template, { 'value': 0 })
		self.assertEquals(ret, 'My value is 0.')

	def test_ignores_misses(self):
		template = "I think {{name}} wants a {{thing}}, right {{name}}?"
		ret = mustache.render(template, { 'name': 'Jon' })
		self.assertEquals(ret, "I think Jon wants a , right Jon?")

 def test_interpolation_19(self):
     template = u'"{{a.b.c.name}}" == ""'
     template = mustache.build(template, partials=None)
     context = {u'a': {u'b': {}}, u'c': {u'name': u'Jim'}}
     rendered = mustache.render(template, context)
     self.assertEqual(rendered, u'"" == ""')

 def test_interpolation_13(self):
     template = u'I ({{&cannot}}) be seen!'
     template = mustache.build(template, partials=None)
     context = {}
     rendered = mustache.render(template, context)
     self.assertEqual(rendered, u'I () be seen!')

	def test_sections(self):
		template = """<ul>{{#users}}<li>{{name}}</li>{{/users}}</ul>"""

		context = { 'users': [ {'name': 'Chris'}, {'name': 'Tom'}, {'name': 'PJ'} ] }
		ret = mustache.render(template, context)
		self.assertEquals(ret, """<ul><li>Chris</li><li>Tom</li><li>PJ</li></ul>""")

	def test_unicode(self):
		template = 'Name: {{name}}; Age: {{age}}'
		ret = mustache.render(template, { 'name': u'Henri Poincaré',
			'age': 156 })
		self.assertEquals(ret, u'Name: Henri Poincaré; Age: 156')

	def test_true_sections_are_shown(self):
		template = "Ready {{#set}}set{{/set}} go!"
		ret = mustache.render(template, { 'set': True })
		self.assertEquals(ret, "Ready set go!")

 def test_partials_10(self):
     template = u'|{{> partial }}|'
     template = mustache.build(template, partials={u'partial': u'[]'})
     context = {u'boolean': True}
     rendered = mustache.render(template, context)
     self.assertEqual(rendered, u'|[]|')

 def test_partials_9(self):
     template = u'\\\n {{>partial}}\n/\n'
     template = mustache.build(template, partials={u'partial': u'|\n{{{content}}}\n|\n'})
     context = {u'content': u'<\n->'}
     rendered = mustache.render(template, context)
     self.assertEqual(rendered, u'\\\n |\n <\n->\n |\n/\n')

 def test_interpolation_29(self):
     template = u'|{{& string }}|'
     template = mustache.build(template, partials=None)
     context = {u'string': u'---'}
     rendered = mustache.render(template, context)
     self.assertEqual(rendered, u'|---|')

 def test_partials_8(self):
     template = u'>\n  {{>partial}}'
     template = mustache.build(template, partials={u'partial': u'>\n>'})
     context = {}
     rendered = mustache.render(template, context)
     self.assertEqual(rendered, u'>\n  >\n  >')

 def test_partials_0(self):
     template = u'"{{>text}}"'
     template = mustache.build(template, partials={u'text': u'from partial'})
     context = {}
     rendered = mustache.render(template, context)
     self.assertEqual(rendered, u'"from partial"')

 def test_interpolation_20(self):
     template = u'"{{#a}}{{b.c.d.e.name}}{{/a}}" == "Phil"'
     template = mustache.build(template, partials=None)
     context = {u'a': {u'b': {u'c': {u'd': {u'e': {u'name': u'Phil'}}}}}, u'b': {u'c': {u'd': {u'e': {u'name': u'Wrong'}}}}}
     rendered = mustache.render(template, context)
     self.assertEqual(rendered, u'"Phil" == "Phil"')

	def test_comments(self):
		template = "What {{! the }} what?"
		ret = mustache.render(template, {})
		self.assertEquals(ret, "What  what?")

 def test_inverted_1(self):
     template = u'"{{^boolean}}This should not be rendered.{{/boolean}}"'
     template = mustache.build(template, partials=None)
     context = {u'boolean': True}
     rendered = mustache.render(template, context)
     self.assertEqual(rendered, u'""')