(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TYPES)
          op: assign_op.Equal
          rhs: {(SQ <'control out in'>)}
          spids: [49]
        )
      ]
    )
    (C {<declare>} {<-i>} {<COUNT>} {<BUFLEN>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:COUNT)
          op: assign_op.Equal
          rhs: {<50000>}
          spids: [95]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:BUFLEN)
          op: assign_op.Equal
          rhs: {<2048>}
          spids: [98]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$DEVICE'))} 
                      {<Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<echo>} {(DQ <'testing ALL recognized usbtest devices'>)})
            (C {<echo>} {(DQ )})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:TEST_ARGS)
                  op: assign_op.Equal
                  rhs: {(DQ <-a>)}
                  spids: [142]
                )
              ]
            )
          ]
          spids: [110 126]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:TEST_ARGS)
              op: assign_op.Equal
              rhs: {(DQ )}
              spids: [150]
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: do_test
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Pipeline
                          children: [
                            (command.Simple
                              words: [
                                {<'./testusb'>}
                                {($ Id.VSub_DollarName '$TEST_ARGS')}
                                {<-s>}
                                {($ Id.VSub_DollarName '$BUFLEN')}
                                {<-c>}
                                {($ Id.VSub_DollarName '$COUNT')}
                                {($ Id.VSub_Star '$*')}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          negated: T
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} {(DQ <FAIL>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [165 187]
                )
              ]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ARGS)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_Star '$*'))}
          spids: [207]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$ARGS'))} 
                      {<Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ARGS)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$TYPES'))}
                  spids: [232]
                )
              ]
            )
          ]
          spids: [213 229]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:CONFIG)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [247]
        )
      ]
    )
    (command.ShFunction
      name: check_config
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$CONFIG'))} 
                              {<Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:CONFIG)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$1')}
                          spids: [279]
                        )
                      ]
                    )
                    (C {<echo>} {(DQ <'assuming '> ($ Id.VSub_DollarName '$CONFIG') <' configuration'>)})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                  spids: [260 276]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$CONFIG'))} 
                              {<Id.Lit_Equals '='>} {($ Id.VSub_Number '$1')} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return>)]
                  spids: [298 313]
                )
              ]
            )
            (C {<echo>} 
              {
                (DQ <'** device must be in '> ($ Id.VSub_Number '$1') <' config, but it\'s '> 
                  ($ Id.VSub_DollarName '$CONFIG') <' instead'>
                )
              }
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (C {<echo>} {(DQ <'TESTING:  '> ($ Id.VSub_DollarName '$ARGS'))})
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: (condition.Shell commands:[(C {<Id.Lit_Colon ':'>} {<true>})])
      body: 
        (command.DoGroup
          children: [
            (C {<echo>} {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<date>}))})
            (command.ForEach
              iter_name: TYPE
              iter_words: [{($ Id.VSub_DollarName '$ARGS')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:COUNT)
                          op: assign_op.Equal
                          rhs: {<5000>}
                          spids: [383]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:BUFLEN)
                          op: assign_op.Equal
                          rhs: {<2048>}
                          spids: [387]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$TYPE')}
                      arms: [
                        (case_arm
                          pat_list: [{<control>}]
                          action: [
                            (C {<echo>} {(SQ <'** Control test cases:'>)})
                            (C {<echo>} {(DQ <'test 9: ch9 postconfig'>)})
                            (C {<do_test>} {<-t>} {<9>} {<-c>} {<5000>})
                            (C {<echo>} {(DQ <'test 10: control queueing'>)})
                            (C {<do_test>} {<-t>} {<10>} {<-c>} {<5000>})
                            (C {<echo>} {(DQ <'test 14: control writes'>)})
                            (C {<do_test>} {<-t>} {<14>} {<-c>} {<15000>} {<-s>} {<256>} {<-v>} {<1>})
                            (C {<echo>} {(DQ <'test 21: control writes, unaligned'>)})
                            (C {<do_test>} {<-t>} {<21>} {<-c>} {<100>} {<-s>} {<256>} {<-v>} {<1>})
                          ]
                          spids: [412 413 523 -1]
                        )
                        (case_arm
                          pat_list: [{<out>}]
                          action: [
                            (C {<check_config>} {<sink-src>})
                            (C {<echo>} {(SQ <'** Host Write (OUT) test cases:'>)})
                            (C {<echo>} 
                              {
                                (DQ <'test 1: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, same size'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<1>})
                            (C {<echo>} 
                              {
                                (DQ <'test 3: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, variable/short size'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<3>} {<-v>} {<421>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<100>}
                                  spids: [581]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 17: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, unaligned DMA map by core'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<17>})
                            (C {<echo>} 
                              {
                                (DQ <'test 19: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, unaligned DMA map by usb_alloc_coherent'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<19>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<2000>}
                                  spids: [619]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 5: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' scatterlists, same size entries'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<5>})
                            (C {<echo>} 
                              {
                                (DQ <'test 7a: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' scatterlists, variable size/short entries'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<7>} {<-v>} {<579>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BUFLEN)
                                  op: assign_op.Equal
                                  rhs: {<4096>}
                                  spids: [664]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 7b: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' scatterlists, variable size/bigger entries'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<7>} {<-v>} {<41>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BUFLEN)
                                  op: assign_op.Equal
                                  rhs: {<64>}
                                  spids: [688]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 7c: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' scatterlists, variable size/micro entries'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<7>} {<-v>} {<63>})
                          ]
                          spids: [527 528 712 -1]
                        )
                        (case_arm
                          pat_list: [{<iso-out>}]
                          action: [
                            (C {<check_config>} {<sink-src>})
                            (C {<echo>} {(SQ <'** Host ISOCHRONOUS Write (OUT) test cases:'>)})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BUFLEN)
                                  op: assign_op.Equal
                                  rhs: {<24500>}
                                  spids: [745]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<1000>}
                                  spids: [750]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 15: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, same size'>
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BUFLEN)
                                  op: assign_op.Equal
                                  rhs: {<32768>}
                                  spids: [772]
                                )
                              ]
                            )
                            (C {<do_test>} {<-t>} {<15>} {<-g>} {<8>} {<-v>} {<0>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<100>}
                                  spids: [801]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 22: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, non aligned'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<22>} {<-g>} {<8>} {<-v>} {<0>})
                          ]
                          spids: [716 717 830 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.KW_In in>}]
                          action: [
                            (C {<check_config>} {<sink-src>})
                            (C {<echo>} {(SQ <'** Host Read (IN) test cases:'>)})
                            (C {<echo>} 
                              {
                                (DQ <'test 2: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, same size'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<2>})
                            (C {<echo>} 
                              {
                                (DQ <'test 4: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, variable size'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<4>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<100>}
                                  spids: [893]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 18: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, unaligned DMA map by core'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<18>})
                            (C {<echo>} 
                              {
                                (DQ <'test 20: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, unaligned DMA map by usb_alloc_coherent'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<20>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<2000>}
                                  spids: [931]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 6: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' scatterlists, same size entries'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<6>})
                            (C {<echo>} 
                              {
                                (DQ <'test 8: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' scatterlists, variable size entries'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<8>})
                          ]
                          spids: [834 835 967 -1]
                        )
                        (case_arm
                          pat_list: [{<iso-in>}]
                          action: [
                            (C {<check_config>} {<sink-src>})
                            (C {<echo>} {(SQ <'** Host ISOCHRONOUS Read (IN) test cases:'>)})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BUFLEN)
                                  op: assign_op.Equal
                                  rhs: {<24500>}
                                  spids: [1000]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<1000>}
                                  spids: [1005]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 16: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, same size'>
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BUFLEN)
                                  op: assign_op.Equal
                                  rhs: {<32768>}
                                  spids: [1027]
                                )
                              ]
                            )
                            (C {<do_test>} {<-t>} {<16>} {<-g>} {<8>} {<-v>} {<0>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<100>}
                                  spids: [1056]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {
                                (DQ <'test 23: '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' transfers, unaligned'>
                                )
                              }
                            )
                            (C {<do_test>} {<-t>} {<23>} {<-g>} {<8>} {<-v>} {<0>})
                          ]
                          spids: [971 972 1085 -1]
                        )
                        (case_arm
                          pat_list: [{<halt>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<2000>}
                                  spids: [1109]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {(DQ <'test 13: '> ($ Id.VSub_DollarName '$COUNT') <' halt set/clear'>)}
                            )
                            (C {<do_test>} {<-t>} {<13>})
                          ]
                          spids: [1089 1090 1129 -1]
                        )
                        (case_arm
                          pat_list: [{<unlink>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<2000>}
                                  spids: [1137]
                                )
                              ]
                            )
                            (C {<echo>} 
                              {(DQ <'test 11: '> ($ Id.VSub_DollarName '$COUNT') <' read unlinks'>)}
                            )
                            (C {<do_test>} {<-t>} {<11>})
                            (C {<echo>} 
                              {(DQ <'test 12: '> ($ Id.VSub_DollarName '$COUNT') <' write unlinks'>)}
                            )
                            (C {<do_test>} {<-t>} {<12>})
                          ]
                          spids: [1133 1134 1174 -1]
                        )
                        (case_arm
                          pat_list: [{<loop>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BUFLEN)
                                  op: assign_op.Equal
                                  rhs: {<2048>}
                                  spids: [1186]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COUNT)
                                  op: assign_op.Equal
                                  rhs: {<32>}
                                  spids: [1190]
                                )
                              ]
                            )
                            (C {<check_config>} {<loopback>})
                            (C {<echo>} 
                              {
                                (DQ <'write '> ($ Id.VSub_DollarName '$COUNT') <' buffers of '> 
                                  ($ Id.VSub_DollarName '$BUFLEN') <' bytes, read them back'>
                                )
                              }
                            )
                            (C {<echo>} 
                              {
                                (DQ <'write '> ($ Id.VSub_DollarName '$COUNT') 
                                  <' variable size buffers, read them back'>
                                )
                              }
                            )
                          ]
                          spids: [1178 1179 1232 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (C {<echo>} 
                              {(DQ <'Don\'t understand test type '> ($ Id.VSub_DollarName '$TYPE'))}
                            )
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                  arg_word: {<1>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [1236 1237 -1 1254]
                        )
                      ]
                    )
                    (C {<echo>} {(SQ )})
                  ]
                )
            )
          ]
        )
    )
  ]
)