self = <test_build_ts.TestTextBuilder object at 0x7f80fc9b3730>

        def test_automodule(self):
>           self._file_contents_eq(
                "automodule",
                dedent(
                    """\
    module.a
    
       type: 7
    
       The thing.
    
    module.aInstance
    
       type: "A"
    
       An instance of class A
    
    module.interfaceInstance
    
       type: "I"
    
       An instance of the interface
    
    module.q
    
       type: { a: string; b: number; }
    
       Another thing.
    
    module.t
    
       type: "TestTypeAlias"<"A">
    
    module.t2
    
       type: "TestTypeAlias2"
    
    module.zInstance
    
       type: "Z"<"A">
    
    async module.f()
    
       Clutches the bundle
    
       Returns:
          Promise<void>
    
    module.functionWithTypeParam<T>(z)
    
       A function with a type parameter!
    
       We'll refer to ourselves: "functionWithTypeParam()"
    
       Type parameters:
          **T** -- The type parameter (extends "A")
    
       Arguments:
          * **z** ("Z"<T>) -- A Z of T
    
       Returns:
          T -- The x field of z
    
    module.z(a, b)
    
       Arguments:
          * **a** (number)
    
          * **b** ({ a: string; b: number; })
    
       Returns:
          number
    
    class module.A()
    
       This is a summary. This is more info.
    
       *exported from* "module"
    
       A.[Symbol․iterator]()
    
       async A.f()
    
          Returns:
             Promise<void>
    
       A.g(a)
    
          Arguments:
             * **a** (number)
    
          Returns:
             number
    
    class module.Z<T>(a, b)
    
       *exported from* "module"
    
       Type parameters:
          **T** -- Description of T (extends "A")
    
       Arguments:
          * **a** (number)
    
          * **b** (number)
    
       Z.x
    
          type: T
    
       Z.z()
    
    interface module.I
    
       Documentation for the interface I
    
       *exported from* "module"
    
    module.TestTypeAlias<T>
    
       type: { a: T; }
    
       A super special type alias
    
       Type parameters:
          **T** -- The whatsit (extends "A")
    
    module.TestTypeAlias2
    
       type: { a: number; }
                    """
                ),
            )
E           assert 'module.TestT...n\n   Z.z()\n' == 'module.a\n\n...: number; }\n'
E             
E             + module.TestTypeAlias<T>
E             + 
E             +    type: { a: T; }
E             + 
E             +    A super special type alias
E             + 
E             +    Type parameters:
E             +       **T** -- The whatsit (extends "A")
E             + 
E             + module.TestTypeAlias2
E             + 
E             +    type: { a: number; }
E             + 
E               module.a
E               
E                  type: 7
E               
E                  The thing.
E               
E               module.aInstance
E               
E                  type: "A"
E               
E                  An instance of class A
E               
E               module.interfaceInstance
E               
E                  type: "I"
E               
E                  An instance of the interface
E               
E               module.q
E               
E                  type: { a: string; b: number; }
E               
E                  Another thing.
E               
E               module.t
E               
E                  type: "TestTypeAlias"<"A">
E               
E               module.t2
E               
E                  type: "TestTypeAlias2"
E               
E               module.zInstance
E               
E                  type: "Z"<"A">
E               
E               async module.f()
E               
E                  Clutches the bundle
E               
E                  Returns:
E                     Promise<void>
E               
E               module.functionWithTypeParam<T>(z)
E               
E                  A function with a type parameter!
E               
E                  We'll refer to ourselves: "functionWithTypeParam()"
E               
E                  Type parameters:
E                     **T** -- The type parameter (extends "A")
E               
E                  Arguments:
E                     * **z** ("Z"<T>) -- A Z of T
E               
E                  Returns:
E                     T -- The x field of z
E               
E               module.z(a, b)
E               
E                  Arguments:
E                     * **a** (number)
E               
E                     * **b** ({ a: string; b: number; })
E               
E                  Returns:
E                     number
E               
E             + interface module.I
E             + 
E             +    Documentation for the interface I
E             + 
E             +    *exported from* "module"
E             + 
E               class module.A()
E               
E                  This is a summary. This is more info.
E               
E                  *exported from* "module"
E               
E                  A.[Symbol․iterator]()
E               
E                  async A.f()
E               
E                     Returns:
E                        Promise<void>
E               
E                  A.g(a)
E               
E                     Arguments:
E                        * **a** (number)
E               
E                     Returns:
E                        number
E               
E               class module.Z<T>(a, b)
E               
E                  *exported from* "module"
E               
E                  Type parameters:
E                     **T** -- Description of T (extends "A")
E               
E                  Arguments:
E                     * **a** (number)
E               
E                     * **b** (number)
E               
E                  Z.x
E               
E                     type: T
E               
E                  Z.z()
E             - 
E             - interface module.I
E             - 
E             -    Documentation for the interface I
E             - 
E             -    *exported from* "module"
E             - 
E             - module.TestTypeAlias<T>
E             - 
E             -    type: { a: T; }
E             - 
E             -    A super special type alias
E             - 
E             -    Type parameters:
E             -       **T** -- The whatsit (extends "A")
E             - 
E             - module.TestTypeAlias2
E             - 
E             -    type: { a: number; }

tests/test_build_ts/test_build_ts.py:248: AssertionError