assemblyscript/tests/compiler/memory.ts at 5d54b3c0c7c6b8951f42d45d1537c61ca4133db4 · AssemblyScript/assemblyscript · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
// === memory.data ===

// Should be static

function test(): i32 {
  const ptr = memory.data(4);
  var value = load<i32>(ptr);
  store<i32>(ptr, value + 1);
  return value;
}

assert(test() == 0);
assert(test() == 1);
assert(test() == 2);

// Should be properly aligned

var ptr = memory.data(1);
assert(ptr + 16 == (ptr = memory.data(1, 16)));
assert(ptr + 8 == (ptr = memory.data(1, 8)));
assert(ptr + 4 == (ptr = memory.data(1, 4)));
assert(ptr + 2 == (ptr = memory.data(1, 2)));
assert(ptr + 1 == (ptr = memory.data(1, 1)));
assert(ptr + 1 == memory.data(1, 16));

// Should be static and properly aligned per generic instance

function testGeneric<T>(): usize {
  const ptr = memory.data(1, 1 << alignof<T>());
  return ptr;
}

ptr = memory.data(1);
assert(ptr + 16 == (ptr = testGeneric<v128>()));
assert(ptr + 8 == (ptr = testGeneric<i64>()));
assert(ptr + 4 == (ptr = testGeneric<i32>()));
assert(ptr + 2 == (ptr = testGeneric<i16>()));
assert(ptr + 1 == (ptr = testGeneric<i8>()));
assert(ptr + 1 == memory.data(1, 16));

// Should work with arrays of values

ptr = memory.data<u8>([1, 2, 3]);
assert(load<u8>(ptr) == 1);
assert(load<u8>(ptr, 1) == 2);
assert(load<u8>(ptr, 2) == 3);

ptr = memory.data<f32>([1.5, 2.5, 3.5]);
assert(load<f32>(ptr) == 1.5);
assert(load<f32>(ptr, 4) == 2.5);
assert(load<f32>(ptr, 8) == 3.5);

// Should be properly aligned when using arrays of values

ptr = memory.data(1);
assert(ptr + 16 == (ptr = memory.data<u8>([1], 16)));
assert(ptr + 8 == (ptr = memory.data<u8>([1], 8)));
assert(ptr + 4 == (ptr = memory.data<u8>([1], 4)));
assert(ptr + 2 == (ptr = memory.data<u8>([1], 2)));
assert(ptr + 1 == (ptr = memory.data<u8>([1], 1)));
assert(ptr + 1 == memory.data<u8>([1], 16));

// Should correctly encode strings to UTF-8

ptr = memory.dataUTF8(":)");
assert(load<u8>(ptr) == 0x3A);
assert(load<u8>(ptr + 1) == 0x29);
assert(load<u8>(ptr + 2) == 0);

ptr = memory.dataUTF8("🐌");
assert(load<u8>(ptr) == 0xF0);
assert(load<u8>(ptr + 1) == 0x9F);
assert(load<u8>(ptr + 2) == 0x90);
assert(load<u8>(ptr + 3) == 0x8C);
assert(load<u8>(ptr + 4) == 0x00);