text: # Originally contributed by Stefan Schukat as part of this arbitrary-sized
  # arrays patch.
  from win32com.client import gencache
  from win32com.test import util
  import unittest
  
  ZeroD = 0
  OneDEmpty = []
  OneD  = [1,2,3]
  TwoD = [
          [1,2,3],
          [1,2,3],
          [1,2,3]
         ]
  
  TwoD1 = [
            [
              [1,2,3,5],
              [1,2,3],
              [1,2,3]
            ],
            [
              [1,2,3],
              [1,2,3],
              [1,2,3]
            ]
         ]
  
  OneD1 = [
            [
              [1,2,3],
              [1,2,3],
              [1,2,3]
            ],
            [
               [1,2,3],
               [1,2,3]
            ]
           ]
  
  OneD2 = [
            [1,2,3],
            [1,2,3,4,5],
            [
               [1,2,3,4,5],
               [1,2,3,4,5],
               [1,2,3,4,5]
            ]
           ]
  
  
  ThreeD = [
            [
              [1,2,3],
              [1,2,3],
              [1,2,3]
            ],
            [
                [1,2,3],
                [1,2,3],
                [1,2,3]
            ]
            ]
  
  FourD = [
            [
              [[1,2,3],[1,2,3],[1,2,3]],
              [[1,2,3],[1,2,3],[1,2,3]],
              [[1,2,3],[1,2,3],[1,2,3]]
            ],
            [
                [[1,2,3],[1,2,3],[1,2,3]],
                [[1,2,3],[1,2,3],[1,2,3]],
                [[1,2,3],[1,2,3],[1,2,3]]
            ]
            ]
  
  LargeD = [
      [ [list(range(10))] * 10],
  ] * 512
  
  def _normalize_array(a):
      if type(a) != type(()):
          return a
      ret = []
      for i in a:
          ret.append(_normalize_array(i))
      return ret
  
  class ArrayTest(util.TestCase):
      def setUp(self):
          self.arr = gencache.EnsureDispatch("PyCOMTest.ArrayTest")
      def tearDown(self):
          self.arr = None
      def _doTest(self, array):
          self.arr.Array = array
          self.failUnlessEqual(_normalize_array(self.arr.Array), array)
      def testZeroD(self):
          self._doTest(ZeroD)
      def testOneDEmpty(self):
          self._doTest(OneDEmpty)
      def testOneD(self):
          self._doTest(OneD)
      def testTwoD(self):
          self._doTest(TwoD)
      def testThreeD(self):
          self._doTest(ThreeD)
      def testFourD(self):
          self._doTest(FourD)
      def testTwoD1(self):
          self._doTest(TwoD1)
      def testOneD1(self):
          self._doTest(OneD1)
      def testOneD2(self):
          self._doTest(OneD2)
      def testLargeD(self):
          self._doTest(LargeD)
  
  if __name__ == "__main__":
      try:
          util.testmain()
      except SystemExit as rc:
          if not rc:
              raise
  