clearing tests

7 files changed, 465 insertions, 442 deletions

diff --git a/test/abi.parsers.js b/test/abi.inputParser.js
index 12bccf5a5..12b735153 100644
--- a/test/abi.parsers.js
+++ b/test/abi.inputParser.js
@@ -423,443 +423,5 @@ describe('abi', function() {
         });
 
     });
-
-    describe('outputParser', function() {
-        it('should parse output string', function() {
-
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: "string" }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-            
-            // then
-            assert.equal(
-                parser.test("0x" + 
-                    "0000000000000000000000000000000000000000000000000000000000000005" +
-                    "68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
-                'hello'
-                );
-            assert.equal(
-                parser.test("0x" + 
-                    "0000000000000000000000000000000000000000000000000000000000000005" +
-                    "776f726c64000000000000000000000000000000000000000000000000000000")[0], 
-                'world'
-                );
-
-        });
-
-        it('should parse output uint', function() {
-
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'uint' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
-            assert.equal(
-                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), 
-                new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
-                );
-            assert.equal(
-                parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), 
-                new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
-                );
-        });
-        
-        it('should parse output uint256', function() {
-
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'uint256' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
-            assert.equal(
-                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), 
-                new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
-                );
-            assert.equal(
-                parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), 
-                new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
-                );
-        });
-
-        it('should parse output uint128', function() {
-
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'uint128' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
-            assert.equal(
-                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), 
-                new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
-                );
-            assert.equal(
-                parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), 
-                new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
-                );
-        });
-
-        it('should parse output int', function() {
-
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'int' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
-            assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
-            assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
-        });
-        
-        it('should parse output int256', function() {
-
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'int256' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
-            assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
-            assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
-        });
-
-        it('should parse output int128', function() {
-
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'int128' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
-            assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
-            assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
-        });
-
-        it('should parse output hash', function() {
-            
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'hash' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(
-                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
-                "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"
-                );
-        });
-        
-        it('should parse output hash256', function() {
-        
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'hash256' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(
-                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
-                "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"
-                );
-        });
-
-        it('should parse output hash160', function() {
-            
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'hash160' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(
-                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
-                "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"
-                );
-            // TODO shouldnt' the expected hash be shorter?
-        });
-
-        it('should parse output address', function() {
-            
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'address' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(
-                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
-                "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
-                );
-        });
-
-        it('should parse output bool', function() {
-            
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: 'bool' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], true);
-            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000000")[0], false);
-            
-
-        });
-
-        it('should parse output real', function() {
-            
-            // given
-            var d = clone(description); 
-
-            d[0].outputs = [
-                { type: 'real' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1);
-            assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); 
-            assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); 
-            assert.equal(parser.test("0xffffffffffffffffffffffffffffffff00000000000000000000000000000000")[0], -1); 
-            
-        });
-
-        it('should parse output ureal', function() {
-
-            // given
-            var d = clone(description); 
-
-            d[0].outputs = [
-                { type: 'ureal' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1);
-            assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); 
-            assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); 
-
-        });
-        
-
-        it('should parse multiple output strings', function() {
-
-            // given
-            var d = clone(description);
-
-            d[0].outputs = [
-                { type: "string" },
-                { type: "string" }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(
-                parser.test("0x" +
-                    "0000000000000000000000000000000000000000000000000000000000000005" +
-                    "0000000000000000000000000000000000000000000000000000000000000005" +
-                    "68656c6c6f000000000000000000000000000000000000000000000000000000" + 
-                    "776f726c64000000000000000000000000000000000000000000000000000000")[0],
-                'hello'
-                );
-            assert.equal(
-                parser.test("0x" +
-                    "0000000000000000000000000000000000000000000000000000000000000005" +
-                    "0000000000000000000000000000000000000000000000000000000000000005" +
-                    "68656c6c6f000000000000000000000000000000000000000000000000000000" + 
-                    "776f726c64000000000000000000000000000000000000000000000000000000")[1],
-                'world'
-                );
-
-        });
-        
-        it('should use proper method name', function () {
-        
-            // given
-            var d = clone(description);
-            d[0].name = 'helloworld(int)';
-            d[0].outputs = [
-                { type: "int" }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.helloworld("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-            assert.equal(parser.helloworld['int']("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-
-        });
-
-
-        it('should parse multiple methods', function () {
-            
-            // given
-            var d =  [{
-                name: "test",
-                type: "function",
-                inputs: [{ type: "int" }],
-                outputs: [{ type: "int" }]
-            },{
-                name: "test2",
-                type: "function",
-                inputs: [{ type: "string" }],
-                outputs: [{ type: "string" }]
-            }];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            //then
-            assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
-            assert.equal(parser.test2("0x" + 
-                    "0000000000000000000000000000000000000000000000000000000000000005" +
-                    "68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
-                "hello"
-                );
-
-        });
-
-        it('should parse output array', function () {
-            
-            // given
-            var d = clone(description);
-            d[0].outputs = [
-                { type: 'int[]' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x" +
-                    "0000000000000000000000000000000000000000000000000000000000000002" + 
-                    "0000000000000000000000000000000000000000000000000000000000000005" + 
-                    "0000000000000000000000000000000000000000000000000000000000000006")[0][0],
-                5
-                );
-            assert.equal(parser.test("0x" +
-                    "0000000000000000000000000000000000000000000000000000000000000002" + 
-                    "0000000000000000000000000000000000000000000000000000000000000005" + 
-                    "0000000000000000000000000000000000000000000000000000000000000006")[0][1],
-                6
-                );
-
-        });
-
-        it('should parse 0x value', function () {
-        
-            // given
-            var d = clone(description);
-            d[0].outputs = [
-                { type: 'int' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x")[0], 0);
-
-        });
-        
-        it('should parse 0x value', function () {
-        
-            // given
-            var d = clone(description);
-            d[0].outputs = [
-                { type: 'uint' }
-            ];
-
-            // when
-            var parser = abi.outputParser(d);
-
-            // then
-            assert.equal(parser.test("0x")[0], 0);
-
-        });
-
-    });
 });
 
diff --git a/test/abi.outputParser.js b/test/abi.outputParser.js
new file mode 100644
index 000000000..723c408f0
--- /dev/null
+++ b/test/abi.outputParser.js
@@ -0,0 +1,461 @@
+var assert = require('assert');
+var BigNumber = require('bignumber.js');
+var abi = require('../lib/abi.js');
+var clone = function (object) { return JSON.parse(JSON.stringify(object)); };
+
+var description =  [{
+    "name": "test",
+    "type": "function",
+    "inputs": [{
+        "name": "a",
+        "type": "uint256"
+    }
+    ],
+    "outputs": [
+    {
+        "name": "d",
+        "type": "uint256"
+    }
+    ]
+}];
+
+describe('abi', function() {
+    describe('outputParser', function() {
+        it('should parse output string', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: "string" }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+            
+            // then
+            assert.equal(
+                parser.test("0x" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
+                'hello'
+                );
+            assert.equal(
+                parser.test("0x" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "776f726c64000000000000000000000000000000000000000000000000000000")[0], 
+                'world'
+                );
+
+        });
+
+        it('should parse output uint', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'uint' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), 
+                new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
+                );
+            assert.equal(
+                parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), 
+                new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
+                );
+        });
+        
+        it('should parse output uint256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'uint256' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), 
+                new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
+                );
+            assert.equal(
+                parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), 
+                new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
+                );
+        });
+
+        it('should parse output uint128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'uint128' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(
+                parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), 
+                new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10)
+                );
+            assert.equal(
+                parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), 
+                new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10)
+                );
+        });
+
+        it('should parse output int', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'int' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
+            assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
+        });
+        
+        it('should parse output int256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'int256' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
+            assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
+        });
+
+        it('should parse output int128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'int128' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+            assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1);
+            assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16);
+        });
+
+        it('should parse output hash', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'hash' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
+                "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"
+                );
+        });
+        
+        it('should parse output hash256', function() {
+        
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'hash256' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
+                "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"
+                );
+        });
+
+        it('should parse output hash160', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'hash160' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
+                "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"
+                );
+            // TODO shouldnt' the expected hash be shorter?
+        });
+
+        it('should parse output address', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'address' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0],
+                "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
+                );
+        });
+
+        it('should parse output bool', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'bool' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], true);
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000000")[0], false);
+            
+
+        });
+
+        it('should parse output real', function() {
+            
+            // given
+            var d = clone(description); 
+
+            d[0].outputs = [
+                { type: 'real' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1);
+            assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); 
+            assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); 
+            assert.equal(parser.test("0xffffffffffffffffffffffffffffffff00000000000000000000000000000000")[0], -1); 
+            
+        });
+
+        it('should parse output ureal', function() {
+
+            // given
+            var d = clone(description); 
+
+            d[0].outputs = [
+                { type: 'ureal' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1);
+            assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); 
+            assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); 
+
+        });
+        
+
+        it('should parse multiple output strings', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: "string" },
+                { type: "string" }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(
+                parser.test("0x" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000" + 
+                    "776f726c64000000000000000000000000000000000000000000000000000000")[0],
+                'hello'
+                );
+            assert.equal(
+                parser.test("0x" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000" + 
+                    "776f726c64000000000000000000000000000000000000000000000000000000")[1],
+                'world'
+                );
+
+        });
+        
+        it('should use proper method name', function () {
+        
+            // given
+            var d = clone(description);
+            d[0].name = 'helloworld(int)';
+            d[0].outputs = [
+                { type: "int" }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.helloworld("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.helloworld['int']("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+
+        });
+
+
+        it('should parse multiple methods', function () {
+            
+            // given
+            var d =  [{
+                name: "test",
+                type: "function",
+                inputs: [{ type: "int" }],
+                outputs: [{ type: "int" }]
+            },{
+                name: "test2",
+                type: "function",
+                inputs: [{ type: "string" }],
+                outputs: [{ type: "string" }]
+            }];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            //then
+            assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test2("0x" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" +
+                    "68656c6c6f000000000000000000000000000000000000000000000000000000")[0],
+                "hello"
+                );
+
+        });
+
+        it('should parse output array', function () {
+            
+            // given
+            var d = clone(description);
+            d[0].outputs = [
+                { type: 'int[]' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x" +
+                    "0000000000000000000000000000000000000000000000000000000000000002" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" + 
+                    "0000000000000000000000000000000000000000000000000000000000000006")[0][0],
+                5
+                );
+            assert.equal(parser.test("0x" +
+                    "0000000000000000000000000000000000000000000000000000000000000002" + 
+                    "0000000000000000000000000000000000000000000000000000000000000005" + 
+                    "0000000000000000000000000000000000000000000000000000000000000006")[0][1],
+                6
+                );
+
+        });
+
+        it('should parse 0x value', function () {
+        
+            // given
+            var d = clone(description);
+            d[0].outputs = [
+                { type: 'int' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x")[0], 0);
+
+        });
+        
+        it('should parse 0x value', function () {
+        
+            // given
+            var d = clone(description);
+            d[0].outputs = [
+                { type: 'uint' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x")[0], 0);
+
+        });
+
+    });
+});
+
diff --git a/test/db.methods.js b/test/db.methods.js
index 8f8f5409f..2ad384579 100644
--- a/test/db.methods.js
+++ b/test/db.methods.js
@@ -1,7 +1,7 @@
 
 var assert = require('assert');
 var web3 = require('../index.js');
-var u = require('./utils.js');
+var u = require('./test.utils.js');
 
 describe('web3', function() {
     describe('db', function() {
diff --git a/test/eth.methods.js b/test/eth.methods.js
index 7a031c4c8..8f10b441d 100644
--- a/test/eth.methods.js
+++ b/test/eth.methods.js
@@ -1,6 +1,6 @@
 var assert = require('assert');
 var web3 = require('../index.js');
-var u = require('./utils.js');
+var u = require('./test.utils.js');
 
 describe('web3', function() {
     describe('eth', function() {
diff --git a/test/shh.methods.js b/test/shh.methods.js
index fe2dae71d..91ca3caba 100644
--- a/test/shh.methods.js
+++ b/test/shh.methods.js
@@ -1,6 +1,6 @@
 var assert = require('assert');
 var web3 = require('../index.js');
-var u = require('./utils.js');
+var u = require('./test.utils.js');
 
 describe('web3', function() {
     describe('shh', function() {
diff --git a/test/utils.js b/test/test.utils.js
index 8a1e9a0b6..8a1e9a0b6 100644
--- a/test/utils.js
+++ b/test/test.utils.js
diff --git a/test/web3.methods.js b/test/web3.methods.js
index d08495dd9..06de41da4 100644
--- a/test/web3.methods.js
+++ b/test/web3.methods.js
@@ -1,6 +1,6 @@
 var assert = require('assert');
 var web3 = require('../index.js');
-var u = require('./utils.js');
+var u = require('./test.utils.js');
 
 describe('web3', function() {
     u.methodExists(web3, 'sha3');