           ObjectHelper = _ObjectHelper_
         ]
 
-      describe 'fromJSON', ->
+      describe.only 'fromJSON', ->
         mock =
           _id: 1
           an_int: 1
           inner:
             an_obj:
-              an_int: 3
+              an_array: [
+                an_int: 3
+              ]
+            
         obj = null
 
         beforeEach ->

          obj = ObjectHelper.fromJson(data)

        it 'should add camelCase aliases to underscore properties', ->
          expect('anInt' in Object.keys(obj), "the alias is not defined as an enumerable property")
            .to.be.true
          expect(obj.anInt, "the alias value is incorrect").to.equal(mock.an_int)
          obj.an_int = obj.an_int + 1
          expect(obj.anInt, "the alias value does not reflect an underscore change")

            .to.equal(obj.anInt)

        it 'should make the camelCase alias enumerable', ->
          expect('anInt' in Object.keys(obj),
                 "the underscore property is still enumerable").to.be.true   

        it 'should make the underscore property non-enumerable', ->
          expect('an_int' in Object.keys(obj),
                 "the underscore property is still enumerable").to.be.false   

        it 'should make the underscore property nonenumerable', ->
          expect(obj.an_int, "an_int is incorrect").to.equal(mock.an_int)   

        it 'should add camelCase aliases to inner objects', ->
          expect('anObj' in Object.keys(obj.inner),
                 "the inner underscore scalar property is not aliased").to.be.true
          expect(obj.inner.anObj.anInt, "the inner reference alias value is incorrect")
            .to.eql(mock.inner.an_obj.an_int)

        it 'should add camelCase aliases to arrays', ->
          expect('anArray' in Object.keys(obj.inner),
                 "the inner underscore array property is not aliased").to.be.true
          expect(obj.inner.anArray.length, "the inner array length is incorrect")
            .to.equal(1)
          item = obj.inner.anArray[0]
          expect('anInt' in Object.keys(item), "the inner array item scalar property" +
                                               " is not aliased").to.be.true

      describe 'prettyPrint', ->
        cycle =
          d: 3
        cycle.ref = cycle
        mock =
          a: 1
          b: [
            c:
              d: 2
          ]
          cycle: cycle

        it 'should print the hierarchy', ->
          expected = [
            '{'
            '    "a": 1,'
            '    "b": ['
            '        {'
            '            "c": {'
            '                "d": 2'
            '            }'
            '        }'
            '    ],'
            '    "cycle": {'
            '        "d": 3,'
            '        "ref": "..."'
            '    }'
            '}'
          ]
          actual = ObjectHelper.prettyPrint(mock).split("\n")
          for i in [0...Math.min(actual.length, expected.length)]
            expect(actual[i], "prettyPrint result line #{ i } is incorrect")
              .to.equal(expected[i])
          expect(actual.length, "prettyPrint result line count is incorrect")
            .to.equal(expected.length)

      describe 'aliasPublicDataProperties', ->
        it 'should alias public value properties', ->
