lib/machine/src/profile/test.zig
daab053ee43316e1809a84551d573ddd1e5bf3d2
1 const std = @import("std");
2 const profile = @import("root.zig");
3
4 test "profile modes are valid and have distinct canonical fingerprints" {
5 const reconstruct = profile.kvmReconstructV1();
6 const continuation = profile.kvmContinuationTestV1();
7 const interpreted = profile.interpretedContinuationTestV1();
8 try profile.validate(reconstruct);
9 try profile.validate(continuation);
10 try profile.validate(interpreted);
11 try std.testing.expect(!std.mem.eql(
12 u8,
13 &(try profile.profileFingerprint(reconstruct)).digest,
14 &(try profile.profileFingerprint(continuation)).digest,
15 ));
16 try std.testing.expect(!std.mem.eql(
17 u8,
18 &(try profile.contractFingerprint(reconstruct)).digest,
19 &(try profile.contractFingerprint(continuation)).digest,
20 ));
21 try std.testing.expect(!std.mem.eql(
22 u8,
23 &(try profile.profileFingerprint(continuation)).digest,
24 &(try profile.profileFingerprint(interpreted)).digest,
25 ));
26 try std.testing.expect(std.mem.eql(
27 u8,
28 &(try profile.contractFingerprint(continuation)).digest,
29 &(try profile.contractFingerprint(interpreted)).digest,
30 ));
31 }
32
33 test "profile wire form round trips and rejects unknown or incompatible bytes" {
34 const expected = profile.kvmContinuationTestV1();
35 var encoded: profile.wire.Wire = undefined;
36 try profile.encode(expected, &encoded);
37 try std.testing.expect(std.meta.eql(expected, try profile.decode(&encoded)));
38 try std.testing.expect(std.mem.allEqual(u8, encoded[144..], 0));
39
40 var invalid = encoded;
41 invalid[8] = 2;
42 try std.testing.expectError(error.UnsupportedVersion, profile.decode(&invalid));
43 invalid = encoded;
44 invalid[16] = 0xff;
45 try std.testing.expectError(error.UnknownProfileField, profile.decode(&invalid));
46 invalid = encoded;
47 invalid[90] = 0xff;
48 invalid[91] = 0xff;
49 try std.testing.expectError(error.UnknownProfileField, profile.decode(&invalid));
50 invalid = encoded;
51 invalid[96] = 0xff;
52 invalid[97] = 0xff;
53 try std.testing.expectError(error.UnknownProfileField, profile.decode(&invalid));
54 invalid = encoded;
55 invalid[100] ^= 1;
56 try std.testing.expectError(error.IncompatibleProfile, profile.decode(&invalid));
57 invalid = encoded;
58 invalid[132] = 0xff;
59 try std.testing.expectError(error.UnknownProfileField, profile.decode(&invalid));
60 invalid = encoded;
61 invalid[133] = 0xff;
62 invalid[134] = 0xff;
63 try std.testing.expectError(error.UnknownProfileField, profile.decode(&invalid));
64 invalid = encoded;
65 invalid[255] = 1;
66 try std.testing.expectError(error.ReservedNonzero, profile.decode(&invalid));
67 invalid = encoded;
68 invalid[26] = 1;
69 invalid[27] = 0;
70 try std.testing.expectError(error.UnknownProfileField, profile.decode(&invalid));
71 invalid = encoded;
72 invalid[42] += 1;
73 try std.testing.expectError(error.IncompatibleProfile, profile.decode(&invalid));
74 }
75
76 test "determinism inventory versions every source and declares assumptions" {
77 const sources = std.meta.tags(profile.DeterminismSource);
78 try std.testing.expectEqual(sources.len, profile.determinism_entries.len);
79 for (sources, profile.determinism_entries) |source, declared| {
80 try std.testing.expectEqual(source, declared.source);
81 try std.testing.expect(declared.version > 0);
82 }
83
84 const instruction = profile.determinism.entry(.backend_instruction_result);
85 try std.testing.expectEqual(
86 profile.DeterminismControlKind.enforced,
87 std.meta.activeTag(instruction.reference),
88 );
89 try std.testing.expectEqual(
90 profile.DeterminismControlKind.assumed,
91 std.meta.activeTag(instruction.kvm),
92 );
93 const process = profile.determinism.entry(.process_crash);
94 try std.testing.expectEqual(
95 profile.DeterminismControlKind.assumed,
96 std.meta.activeTag(process.reference),
97 );
98 try std.testing.expectEqual(
99 profile.DeterminismControlKind.assumed,
100 std.meta.activeTag(process.kvm),
101 );
102 }
103
104 test "determinism claims separate four evidence levels" {
105 const portable = profile.interpretedContinuationTestV1();
106 try expectClaim(.enforced, portable.claims.semantic);
107 try expectClaim(.enforced, portable.claims.same_backend_whole_system);
108 try expectClaim(.assumed, portable.claims.cross_host);
109 try expectClaim(.assumed, portable.claims.instruction_exact);
110
111 const kvm = profile.kvmContinuationTestV1();
112 try expectClaim(.assumed, kvm.claims.semantic);
113 try expectClaim(.assumed, kvm.claims.same_backend_whole_system);
114 try expectClaim(.assumed, kvm.claims.cross_host);
115 try expectClaim(.assumed, kvm.claims.instruction_exact);
116 }
117
118 test "every profile capacity accepts C and rejects C plus one" {
119 const value = profile.kvmContinuationTestV1();
120 var requested: profile.Usage = .{};
121 for (std.meta.tags(profile.Capacity)) |kind| {
122 requested = .{};
123 const limit = profile.capacity.capacity(value, kind);
124 requested.set(kind, limit);
125 try profile.capacity.usage(value, requested);
126 requested.set(kind, limit + 1);
127 try std.testing.expectError(
128 error.CapacityExceeded,
129 profile.capacity.usage(value, requested),
130 );
131 }
132 }
133
134 test "fixed instance geometry rejects every changed field" {
135 const value = profile.kvmContinuationTestV1();
136 try profile.capacity.geometry(value, value.contract.geometry);
137 var geometry = value.contract.geometry;
138 geometry.vcpu_count += 1;
139 try std.testing.expectError(
140 error.IncompatibleGeometry,
141 profile.capacity.geometry(value, geometry),
142 );
143 geometry = value.contract.geometry;
144 geometry.page_bytes += 1;
145 try std.testing.expectError(
146 error.IncompatibleGeometry,
147 profile.capacity.geometry(value, geometry),
148 );
149 geometry = value.contract.geometry;
150 geometry.ram_base += 1;
151 try std.testing.expectError(
152 error.IncompatibleGeometry,
153 profile.capacity.geometry(value, geometry),
154 );
155 geometry = value.contract.geometry;
156 geometry.ram_bytes += 1;
157 try std.testing.expectError(
158 error.IncompatibleGeometry,
159 profile.capacity.geometry(value, geometry),
160 );
161 }
162
163 test "continuation contract and profile fingerprints are pinned" {
164 const expected_contract = "08895219e35d75564eb7a082b70390c40a83d8856ae5d7820c5c950f437decce";
165 const expected_profile = "10bf57ba10557c16a5194c141ba9bba3191f629f5e495652c57468295f9b21cd";
166 const contract = (try profile.contractFingerprint(profile.kvmContinuationTestV1())).hex();
167 const actual = (try profile.profileFingerprint(profile.kvmContinuationTestV1())).hex();
168 try std.testing.expectEqualStrings(expected_contract, &contract);
169 try std.testing.expectEqualStrings(expected_profile, &actual);
170 }
171
172 fn expectClaim(
173 expected: profile.DeterminismClaimKind,
174 actual: profile.DeterminismClaim,
175 ) !void {
176 try std.testing.expectEqual(expected, std.meta.activeTag(actual));
177 }