Moving some bytes and array tests to semanticTests

test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dyn_dyn.sol

@@ -0,0 +1,22 @@
+
+contract c {
+    uint[] data1;
+    uint[] data2;
+    function setData1(uint length, uint index, uint value) public {
+        data1 = new uint[](length);
+        if (index < length)
+            data1[index] = value;
+    }
+    function copyStorageStorage() public { data2 = data1; }
+    function getData2(uint index) public returns (uint len, uint val) {
+        len = data2.length; if (index < len) val = data2[index];
+    }
+}
+// ----
+// setData1(uint256,uint256,uint256): 10, 5, 4 ->
+// copyStorageStorage() ->
+// getData2(uint256): 5 -> 10, 4
+// setData1(uint256,uint256,uint256): 0, 0, 0 ->
+// copyStorageStorage() ->
+// getData2(uint256): 0 -> 0, 0
+// storage: empty

test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_struct.sol

@@ -0,0 +1,20 @@
+contract c {
+    struct Data { uint x; uint y; }
+    Data[] data1;
+    Data[] data2;
+    function test() public returns (uint x, uint y) {
+        while (data1.length < 9)
+            data1.push();
+        data1[8].x = 4;
+        data1[8].y = 5;
+        data2 = data1;
+        x = data2[8].x;
+        y = data2[8].y;
+        while (data1.length > 0)
+            data1.pop();
+        data2 = data1;
+    }
+}
+// ----
+// test() -> 4, 5
+// storage: empty

test/libsolidity/semanticTests/array/copying/array_copy_target_leftover.sol

@@ -0,0 +1,19 @@
+contract c {
+    byte[10] data1;
+    bytes2[32] data2;
+    function test() public returns (uint check, uint res1, uint res2) {
+        uint i;
+        for (i = 0; i < data2.length; ++i)
+            data2[i] = 0xffff;
+        check = uint(uint16(data2[31])) * 0x10000 | uint(uint16(data2[14]));
+        for (i = 0; i < data1.length; ++i)
+            data1[i] = byte(uint8(1 + i));
+        data2 = data1;
+        for (i = 0; i < 16; ++i)
+            res1 |= uint(uint16(data2[i])) * 0x10000**i;
+        for (i = 0; i < 16; ++i)
+            res2 |= uint(uint16(data2[16 + i])) * 0x10000**i;
+    }
+}
+// ----
+// test() -> 0xffffffff, 0x0000000000000000000000000a00090008000700060005000400030002000100, 0x0000000000000000000000000000000000000000000000000000000000000000

test/libsolidity/semanticTests/array/copying/bytes_inside_mappings.sol

@@ -0,0 +1,15 @@
+contract c {
+    function set(uint key) public returns (bool) { data[key] = msg.data; return true; }
+    function copy(uint from, uint to) public returns (bool) { data[to] = data[from]; return true; }
+    mapping(uint => bytes) data;
+}
+// ----
+// set(uint256): 1, 2 -> true
+// set(uint256): 2, 2, 3, 4, 5 -> true
+// storage: nonempty
+// copy(uint256,uint256): 1, 2 -> true
+// storage: nonempty
+// copy(uint256,uint256): 99, 1 -> true
+// storage: nonempty
+// copy(uint256,uint256): 99, 2 -> true
+// storage: empty

test/libsolidity/semanticTests/array/copying/copy_removes_bytes_data.sol

@@ -0,0 +1,12 @@
+
+contract c {
+    function set() public returns (bool) { data1 = msg.data; return true; }
+    function reset() public returns (bool) { data1 = data2; return true; }
+    bytes data1;
+    bytes data2;
+}
+// ----
+// set(): 1, 2, 3, 4, 5 -> true
+// storage: nonempty
+// reset() -> true
+// storage: empty