Merge branch 'master' of git://pyxb.git.sourceforge.net/gitroot/pyxb/pyxbHEADmaster

12 files changed, 268 insertions, 202 deletions

diff --git a/tests/bindings/test-constraints.py b/tests/bindings/test-constraints.py
index 22dc87d..b3f8094 100644
--- a/tests/bindings/test-constraints.py
+++ b/tests/bindings/test-constraints.py
@@ -227,5 +227,12 @@ class testWhitespace (unittest.TestCase):
         self.assertEqual("test", CollapseString(u"\ttest\n\r"))
         self.assertEqual("test too", CollapseString(u"\ttest\n\rtoo\n"))
 
+    def testApplyWhitespace (self):
+        goal = 'one two'
+        source = '  one    two   '
+        self.assertEqual(goal, CollapseString(goal))
+        self.assertEqual(goal, CollapseString(source))
+        self.assertEqual(source, CollapseString(source, _apply_whitespace_facet=False))
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/bindings/test-nfa.py b/tests/bindings/test-nfa.py
deleted file mode 100644
index 983b70c..0000000
--- a/tests/bindings/test-nfa.py
+++ /dev/null
@@ -1,199 +0,0 @@
-import unittest
-from pyxb.utils.utility import *
-from pyxb.utils.utility import _DeconflictSymbols_mixin
-
-'''
-
-class TestThompson (unittest.TestCase):
-
-    def testParticleOne (self):
-        t = Thompson(Particle(1,1,'a'))
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertFalse(nfa.isFullPath([]))
-            self.assertTrue(nfa.isFullPath(['a']))
-            self.assertFalse(nfa.isFullPath(['a', 'a']))
-
-    def testParticleOptional (self):
-        t = Thompson(Particle(0,1,'a'))
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertTrue(nfa.isFullPath([]))
-            self.assertTrue(nfa.isFullPath(['a']))
-            self.assertFalse(nfa.isFullPath(['a', 'a']))
-
-    def testParticleAny (self):
-        t = Thompson(Particle(0,None,'a'))
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertTrue(nfa.isFullPath([]))
-            self.assertTrue(nfa.isFullPath(['a']))
-            for rep in range(0, 10):
-                self.assertTrue(nfa.isFullPath(rep * ['a']))
-
-    def testParticle2Plus (self):
-        particle = Particle(2, None, 'a')
-        t = Thompson(particle)
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            for rep in range(1, 10):
-                if particle.minOccurs() <= rep:
-                    self.assertTrue(nfa.isFullPath(rep * ['a']))
-                else:
-                    self.assertFalse(nfa.isFullPath(rep * ['a']))
-
-    def testParticleSome (self):
-        particle = Particle(3, 5, 'a')
-        t = Thompson(particle)
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            for rep in range(1, 10):
-                if (particle.minOccurs() <= rep) and (rep <= particle.maxOccurs()):
-                    self.assertTrue(nfa.isFullPath(rep * ['a']))
-                else:
-                    self.assertFalse(nfa.isFullPath(rep * ['a']))
-
-    def testSequence1 (self):
-        seq = ModelGroup(ModelGroup.C_SEQUENCE, [ 'a' ])
-        t = Thompson(seq)
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertFalse(nfa.isFullPath([ ]))
-            self.assertTrue(nfa.isFullPath([ 'a' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'b' ]))
-
-    def testSequence3 (self):
-        seq = ModelGroup(ModelGroup.C_SEQUENCE, [ 'a', 'b', 'c' ])
-        t = Thompson(seq)
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertFalse(nfa.isFullPath([ ]))
-            self.assertFalse(nfa.isFullPath([ 'a' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'b' ]))
-            self.assertTrue(nfa.isFullPath([ 'a', 'b', 'c' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'b', 'c', 'd' ]))
-
-    def testChoice1 (self):
-        seq = ModelGroup(ModelGroup.C_CHOICE, [ 'a' ])
-        t = Thompson(seq)
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertFalse(nfa.isFullPath([ ]))
-            self.assertTrue(nfa.isFullPath([ 'a' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'b' ]))
-
-    def testChoice3 (self):
-        seq = ModelGroup(ModelGroup.C_CHOICE, [ 'a', 'b', 'c' ])
-        t = Thompson(seq)
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertFalse(nfa.isFullPath([ ]))
-            self.assertTrue(nfa.isFullPath([ 'a' ]))
-            self.assertTrue(nfa.isFullPath([ 'b' ]))
-            self.assertTrue(nfa.isFullPath([ 'c' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'b' ]))
-
-    def testAll1 (self):
-        seq = ModelGroup(ModelGroup.C_ALL, [ 'a' ])
-        t = Thompson(seq)
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertFalse(nfa.isFullPath([ ]))
-            self.assertTrue(nfa.isFullPath([ 'a' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'a' ]))
-
-    def testAll2 (self):
-        seq = ModelGroup(ModelGroup.C_ALL, [ 'a', 'b' ])
-        t = Thompson(seq)
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertFalse(nfa.isFullPath([ ]))
-            self.assertFalse(nfa.isFullPath([ 'a' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'a' ]))
-            self.assertTrue(nfa.isFullPath([ 'a', 'b' ]))
-            self.assertTrue(nfa.isFullPath([ 'b', 'a' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'b', 'a' ]))
-            self.assertFalse(nfa.isFullPath([ 'b', 'a', 'b' ]))
-
-    def testAll3 (self):
-        seq = ModelGroup(ModelGroup.C_ALL, [ 'a', 'b', 'c' ])
-        t = Thompson(seq)
-        for nfa in (t.nfa(), t.nfa().buildDFA()):
-            self.assertFalse(nfa.isFullPath([ ]))
-            self.assertFalse(nfa.isFullPath([ 'a' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'a' ]))
-            self.assertFalse(nfa.isFullPath([ 'a', 'b' ]))
-            self.assertFalse(nfa.isFullPath([ 'b', 'a' ]))
-            self.assertTrue(nfa.isFullPath([ 'a', 'b', 'c' ]))
-            self.assertTrue(nfa.isFullPath([ 'a', 'c', 'b' ]))
-            self.assertTrue(nfa.isFullPath([ 'b', 'a', 'c' ]))
-            self.assertTrue(nfa.isFullPath([ 'b', 'c', 'a' ]))
-            self.assertTrue(nfa.isFullPath([ 'c', 'a', 'b' ]))
-            self.assertTrue(nfa.isFullPath([ 'c', 'b', 'a' ]))
-
-class TestFiniteAutomaton (unittest.TestCase):
-    def testSubAutomaton (self):
-        subnfa = FiniteAutomaton()
-        subnfa.addTransition('a', subnfa.start(), subnfa.end())
-        nfa = FiniteAutomaton()
-        ( start, end ) = nfa.addSubAutomaton(subnfa)
-        nfa.addTransition('b', nfa.start(), start)
-        nfa.addTransition('c', end, nfa.end())
-        self.assertFalse(nfa.isFullPath([ ]))
-        self.assertTrue(nfa.isFullPath(['b', 'a', 'c']))
-
-    def testSubAutomaton (self):
-        subnfa = FiniteAutomaton()
-        subnfa.addTransition('a', subnfa.start(), subnfa.end())
-        nfa = FiniteAutomaton()
-        ( start, end ) = nfa.addSubAutomaton(subnfa)
-        nfa.addTransition('b', nfa.start(), start)
-        nfa.addTransition(None, end, nfa.end())
-        ( start, end ) = nfa.addSubAutomaton(subnfa)
-        nfa.addTransition(None, nfa.start(), start)
-        nfa.addTransition('b', end, nfa.end())
-
-        self.assertFalse(nfa.isFullPath([ ]))
-        self.assertTrue(nfa.isFullPath(['b', 'a']))
-        self.assertTrue(nfa.isFullPath(['a', 'b']))
-        self.assertFalse(nfa.isFullPath(['a', 'a']))
-        self.assertFalse(nfa.isFullPath(['b', 'a', 'b']))
-        self.assertFalse(nfa.isFullPath(['a', 'b', 'a']))
-
-    def testDFA (self):
-        nfa = FiniteAutomaton()
-        q1 = nfa.newState()
-        nfa.addTransition(None, nfa.start(), q1)
-        nfa.addTransition('a', q1, q1)
-        nfa.addTransition('b', q1, q1)
-        q2 = nfa.newState()
-        nfa.addTransition('a', q1, q2)
-        q3 = nfa.newState()
-        nfa.addTransition('b', q2, q3)
-        nfa.addTransition('b', q3, nfa.end())
-        dfa = nfa.buildDFA()
-
-class TestPermutations (unittest.TestCase):
-    def testPermutations (self):
-        p1 = set(_Permutations(['a']))
-        self.assertEqual(1, len(p1))
-
-        p2 = set(_Permutations(['a', 'b']))
-        self.assertEqual(2, len(p2))
-        self.assertTrue(('a', 'b') in p2)
-        self.assertTrue(('b', 'a') in p2)
-
-        p3 = set(_Permutations(['a', 'b', 'c']))
-        self.assertEqual(6, len(p3))
-        self.assertTrue(('a', 'b', 'c') in p3)
-        self.assertTrue(('a', 'c', 'b') in p3)
-        self.assertTrue(('b', 'a', 'c') in p3)
-        self.assertTrue(('b', 'c', 'a') in p3)
-        self.assertTrue(('c', 'a', 'b') in p3)
-        self.assertTrue(('c', 'b', 'a') in p3)
-
-class TestSchema (unittest.TestCase):
-    def testWsdl (self):
-        x = ModelGroup(ModelGroup.C_CHOICE, [ 'a', 'b', 'c' ])
-        x = ModelGroup(ModelGroup.C_SEQUENCE, [ Particle(0, None, x) ])
-        x = ModelGroup(ModelGroup.C_SEQUENCE, [ Particle(0, None, 'W'), x ])
-        x = ModelGroup(ModelGroup.C_SEQUENCE, [ Particle(0, 1, 'd'), x ])
-        t = Thompson(x)
-        for nfa in ( t.nfa(), t.nfa().buildDFA() ):
-            self.assertTrue(nfa.isFullPath([ 'd' ]))
-            self.assertFalse(nfa.isFullPath([ 'd', 'd' ]))
-                                          
-if __name__ == '__main__':
-    unittest.main()
-    
-'''
-    
diff --git a/tests/drivers/test-ctd-extension.py b/tests/drivers/test-ctd-extension.py
index fd75642..590f8bb 100644
--- a/tests/drivers/test-ctd-extension.py
+++ b/tests/drivers/test-ctd-extension.py
@@ -56,7 +56,7 @@ class TestCTDExtension (unittest.TestCase):
         self.assertEqual('add generation', instance.eAttr)
 
     def testMidWildcard (self):
-        xml = '<defs><documentation/><something/><message/><message/><import/><message/></defs>'
+        xml = '<defs xmlns:other="other"><documentation/><other:something/><message/><message/><import/><message/></defs>'
         doc = pyxb.utils.domutils.StringToDOM(xml)
         instance = defs.createFromDOM(doc.documentElement)
         self.assertFalse(instance.documentation is None)
@@ -64,7 +64,7 @@ class TestCTDExtension (unittest.TestCase):
         self.assertEqual(1, len(instance.import_))
         self.assertEqual(1, len(instance.wildcardElements()))
 
-        xml = '<defs><something/><else/><message/><message/><import/><message/></defs>'
+        xml = '<defs xmlns:other="other"><other:something/><other:else/><message/><message/><import/><message/></defs>'
         doc = pyxb.utils.domutils.StringToDOM(xml)
         instance = defs.createFromDOM(doc.documentElement)
         self.assertTrue(instance.documentation is None)
@@ -73,7 +73,7 @@ class TestCTDExtension (unittest.TestCase):
         self.assertEqual(2, len(instance.wildcardElements()))
 
     def testEndWildcard (self):
-        xml = '<defs><message/><something/></defs>'
+        xml = '<defs xmlns:other="other"><message/><other:something/></defs>'
         doc = pyxb.utils.domutils.StringToDOM(xml)
         self.assertRaises(ExtraContentError, defs.createFromDOM, doc.documentElement)
 
diff --git a/tests/trac/test-trac-0033a.py b/tests/trac/test-trac-0033a.py
new file mode 100644
index 0000000..66f3902
--- /dev/null
+++ b/tests/trac/test-trac-0033a.py
@@ -0,0 +1,54 @@
+import pyxb.binding.generate
+import pyxb.utils.domutils
+from xml.dom import Node
+
+import os.path
+xsd='''<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+<xs:complexType name="tAddress">
+  <xs:choice>
+    <xs:sequence>
+      <xs:element name="Line1" type="xs:string"/>
+      <xs:element name="Line2" type="xs:string"/>
+    </xs:sequence>
+    <xs:sequence>
+      <xs:element name="Missing" type="xs:string"/>
+    </xs:sequence>
+  </xs:choice>
+</xs:complexType>
+<xs:complexType name="tOther">
+  <xs:sequence>
+    <xs:element name="Header" type="xs:string"/>
+    <xs:choice>
+      <xs:sequence>
+        <xs:element name="Special" type="tAddress"/>
+        <xs:element name="Common" type="tAddress" minOccurs="0"/>
+      </xs:sequence>
+      <xs:sequence>
+        <xs:element name="Common" type="tAddress"/>
+      </xs:sequence>
+    </xs:choice>
+  </xs:sequence>
+</xs:complexType>
+<xs:element name="elt" type="tOther"/>
+</xs:schema>'''
+
+code = pyxb.binding.generate.GeneratePython(schema_text=xsd)
+file('code.py', 'w').write(code)
+#print code
+
+rv = compile(code, 'test', 'exec')
+eval(rv)
+
+from pyxb.exceptions_ import *
+
+import unittest
+
+class TestTrac0033a (unittest.TestCase):
+    def test (self):
+        xml = '<elt><Header/><Common><Line1/><Line2/></Common></elt>'
+        instance = CreateFromDocument(xml)
+
+if __name__ == '__main__':
+    unittest.main()
+    
diff --git a/tests/trac/trac-0033/test.sh b/tests/trac/trac-0033/test.sh
new file mode 100755
index 0000000..da464a9
--- /dev/null
+++ b/tests/trac/trac-0033/test.sh
@@ -0,0 +1,7 @@
+fail () {
+  echo 1>&2 "${test_name} FAILED: ${@}"
+  exit 1
+}
+
+python tread.py || fail trac33
+echo 'trac33 passed'
diff --git a/tests/trac/trac-0033/tread.py b/tests/trac/trac-0033/tread.py
new file mode 100644
index 0000000..08b0b8c
--- /dev/null
+++ b/tests/trac/trac-0033/tread.py
@@ -0,0 +1,51 @@
+import time
+import pyxb.binding.generate
+import pyxb.utils.domutils
+
+max_reps = 20
+
+def buildTest (num_reps, constraint='minOccurs="0" maxOccurs="1"'):
+    edefs = []
+    cdefs = []
+    duse = []
+    for r in xrange(num_reps):
+        edefs.append('<xs:element name="rep%d" type="xs:string"/>' % (r,))
+        cdefs.append('<xs:element ref="rep%d" %s/>' % (r, constraint))
+        duse.append('<rep%d>text_%d</rep%d>' % (r, r, r))
+
+    schema = ''.join([ '''<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">''',
+                   "\n".join(edefs),
+                   '''<xs:element name="collection">
+<xs:complexType><xs:sequence>''',
+                   "\n".join(cdefs),
+                   '''</xs:sequence></xs:complexType>
+</xs:element>
+</xs:schema>''' ])
+
+    xmls = '<collection>' + ''.join(duse) + '</collection>'
+    
+    return (schema, xmls)
+
+for size in xrange(1, max_reps):
+    (schema, xmls) = buildTest(size)
+
+    t0 = time.time()
+    code = pyxb.binding.generate.GeneratePython(schema_text=schema)
+    t1 = time.time()
+    rv = compile(code, 'test', 'exec')
+    t2 = time.time()
+    eval(rv)
+    t3 = time.time()
+    #file('code.py', 'w').write(code)
+    #print xmls
+    ct0 = time.time()
+    doc = CreateFromDocument(xmls)
+    ct1 = time.time()
+
+    print "%d gen=%g cpl=%g ld=%g prs=%g" % (size, t1 - t0, t2 - t1, t3 - t2, ct1 - ct0)
+    # Should not take more than a second (really, less than 10ms)
+    assert (ct1 - ct0) < 1.0
+    #file('code.py', 'w').write(code)
+
+
diff --git a/tests/trac/trac-0080/check.py b/tests/trac/trac-0080/check.py
new file mode 100644
index 0000000..54dfa55
--- /dev/null
+++ b/tests/trac/trac-0080/check.py
@@ -0,0 +1,65 @@
+import mr
+import unittest
+import pyxb
+import pyxb.binding.datatypes as xsd
+
+class TestTrac0080 (unittest.TestCase):
+
+    _NotANormalizedString = "\nmulti\nline\ttabbed\n"
+    _NotAToken = ' leading spaces '
+    _NotAnNCName = 'internal spaces'
+    _NCName = 'simple'
+    
+    def assignAttribute_ (self, instance, value):
+        instance.anAttribute = value
+
+    def testType4 (self): # base
+        v = xsd.normalizedString(self._NotANormalizedString)
+        i4 = mr.Type4()
+        au = i4._AttributeMap.get('anAttribute')
+        self.assertEqual(au.dataType(), xsd.normalizedString)
+        self.assertFalse(au.required())
+        # BTW: If you wonder why this works, it's because the
+        # whiteSpace facet on xsd:normalizedString is replace.
+        self.assignAttribute_(i4, self._NotANormalizedString)
+        self.assertEqual(i4.anAttribute, ' multi line tabbed ')
+
+    def testType3 (self): # restrict type
+        i3 = mr.Type3()
+        au = i3._AttributeMap.get('anAttribute')
+        self.assertEqual(au.dataType(), xsd.token)
+        self.assertNotEqual(au, mr.Type4._AttributeMap.get(au.name()))
+        self.assertFalse(au.required())
+        #self.assertRaises(pyxb.BadTypeValueError, self.assignAttribute_, i3, self._NotAToken)
+        self.assignAttribute_(i3, self._NotAnNCName)
+        self.assertEqual(self._NotAnNCName, i3.anAttribute)
+
+    def testType2 (self): # extend isSet
+        i2 = mr.Type2()
+        au = i2._AttributeMap.get('anAttribute')
+        self.assertEqual(au.dataType(), xsd.token)
+        self.assertEqual(au, mr.Type3._AttributeMap.get(au.name()))
+        self.assertFalse(au.required())
+
+    def testType1 (self): # restrict type
+        i1 = mr.Type1()
+        au = i1._AttributeMap.get('anAttribute')
+        self.assertEqual(au.dataType(), xsd.NCName)
+        self.assertFalse(au.required())
+        # The whiteSpace facet on xsd:token is collapse, which does
+        # not remove the interior space.
+        self.assertRaises(pyxb.BadTypeValueError, self.assignAttribute_, i1, self._NotAToken)
+        self.assertRaises(pyxb.BadTypeValueError, self.assignAttribute_, i1, self._NotAnNCName)
+        self.assignAttribute_(i1, self._NCName)
+        self.assertEqual(self._NCName, i1.anAttribute)
+
+    def testRoot (self): # restrict required
+        r = mr.root()
+        rt = type(r)
+        au = rt._AttributeMap.get('anAttribute')
+        self.assertEqual(au.dataType(), xsd.NCName)
+        self.assertTrue(au.required())
+        self.assertRaises(pyxb.MissingAttributeError, r.validateBinding)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/trac/trac-0080/multipleRestriction.xsd b/tests/trac/trac-0080/multipleRestriction.xsd
new file mode 100644
index 0000000..dd47ec7
--- /dev/null
+++ b/tests/trac/trac-0080/multipleRestriction.xsd
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<schema xmlns="http://www.w3.org/2001/XMLSchema" 
+        targetNamespace="http://www.example.org/multipleRestriction"
+        xmlns:tns="http://www.example.org/multipleRestriction"
+        elementFormDefault="qualified">
+
+   <complexType name="Type4">
+      <attribute name="anAttribute" type="normalizedString" use="optional" />
+   </complexType>
+
+   <complexType name="Type3">
+      <complexContent>
+         <restriction base="tns:Type4">
+            <attribute name="anAttribute" type="token" use="optional" />
+         </restriction>
+      </complexContent>
+   </complexType>
+
+   <complexType name="Type2">
+      <complexContent>
+         <extension base="tns:Type3">
+            <sequence>
+               <element minOccurs="0" maxOccurs="1" name="isSet" type="boolean" />
+            </sequence>
+         </extension>
+      </complexContent>
+   </complexType>
+
+   <complexType name="Type1">
+      <complexContent>
+         <restriction base="tns:Type2">
+            <sequence>
+               <element minOccurs="0" maxOccurs="1" name="isSet" type="boolean" />
+            </sequence>
+            <attribute name="anAttribute" type="NCName" use="optional" />
+         </restriction>
+      </complexContent>
+   </complexType>
+
+   <element name="root">
+      <complexType>
+         <complexContent>
+            <restriction base="tns:Type1">
+               <sequence>
+                  <element minOccurs="0" maxOccurs="1" name="isSet" type="boolean" />
+               </sequence>
+               <attribute name="anAttribute" type="NCName" use="required" />
+            </restriction>
+         </complexContent>
+      </complexType>
+   </element>
+</schema>
+
diff --git a/tests/trac/trac-0080/test.sh b/tests/trac/trac-0080/test.sh
new file mode 100755
index 0000000..b40849b
--- /dev/null
+++ b/tests/trac/trac-0080/test.sh
@@ -0,0 +1,2 @@
+pyxbgen -u multipleRestriction.xsd -m mr
+python check.py
diff --git a/tests/trac/trac-0084/example.xsd b/tests/trac/trac-0084/example.xsd
new file mode 100644
index 0000000..fdc15be
--- /dev/null
+++ b/tests/trac/trac-0084/example.xsd
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema
+    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    targetNamespace="http://schema.example.com/SUBSYSTEM/1.0"
+    xmlns:tns="http://schema.example.com/SUBSYSTEM/1.0"
+    elementFormDefault="qualified"
+    version="1.0">
+
+    <xsd:complexType name="XVendorConfig">
+        <xsd:sequence>
+            <xsd:any namespace="##local" processContents="skip" minOccurs="0" maxOccurs="unbounded"/>
+        </xsd:sequence>
+    </xsd:complexType>
+
+</xsd:schema>
diff --git a/tests/trac/trac-0084/test.sh b/tests/trac/trac-0084/test.sh
new file mode 100755
index 0000000..66c9af9
--- /dev/null
+++ b/tests/trac/trac-0084/test.sh
@@ -0,0 +1,10 @@
+pyxbgen -u example.xsd -m example
+
+fail () {
+  echo 1>&2 "${test_name} FAILED: ${@}"
+  exit 1
+}
+
+python tryit.py || fail 'Unable to read generated code'
+echo 'Successfully read code, passed'
+
diff --git a/tests/trac/trac-0084/tryit.py b/tests/trac/trac-0084/tryit.py
new file mode 100644
index 0000000..d2d2de6
--- /dev/null
+++ b/tests/trac/trac-0084/tryit.py
@@ -0,0 +1 @@
+from example import *