Commit 33682a29c6feadaf14cd8ad37f6a9480eda2d49a | zig

author	FnControlOption <fncontroloption@noreply.codeberg.org> 2023-01-22 07:16:49-08:00
committer	FnControlOption <fncontroloption@noreply.codeberg.org> 2023-01-22 07:16:49-08:00
log	33682a29c6feadaf14cd8ad37f6a9480eda2d49a
tree	05688e7537b6151eebea2977029d74148ece8e7e
parent	6089ed9ee77ed034a39c2b557f4608cd8d779d3f

Rewrite update_crc_catalog in zig and move tests to separate file

6 files changed, 2438 insertions(+), 1521 deletions(-)

lib
- std
  - hash
    crc.zig
    crc
    catalog.zig
    catalog_test.zig
tools

lib/std/hash/crc.zig+16-18

...	...	@@ -14,13 +14,11 @@ pub usingnamespace @import("crc/catalog.zig");
14	14
15	15	pub fn Algorithm(comptime W: type) type {
16	16	return struct {
17		poly: W,
18		init: W,
19		refin: bool,
20		refout: bool,
21		xorout: W,
22		check: W,
23		residue: W,
	17	polynomial: W,
	18	initial: W,
	19	reflect_input: bool,
	20	reflect_output: bool,
	21	xor_output: W,
24	22	};
25	23	}
26	24
...	...	@@ -31,15 +29,15 @@ pub fn Crc(comptime W: type, comptime algorithm: Algorithm(W)) type {
31	29	const lookup_table = blk: {
32	30	@setEvalBranchQuota(2500);
33	31
34		const poly = if (algorithm.refin)
35		@bitReverse(@as(I, algorithm.poly)) >> (@bitSizeOf(I) - @bitSizeOf(W))
	32	const poly = if (algorithm.reflect_input)
	33	@bitReverse(@as(I, algorithm.polynomial)) >> (@bitSizeOf(I) - @bitSizeOf(W))
36	34	else
37		@as(I, algorithm.poly) << (@bitSizeOf(I) - @bitSizeOf(W));
	35	@as(I, algorithm.polynomial) << (@bitSizeOf(I) - @bitSizeOf(W));
38	36
39	37	var table: [256]I = undefined;
40	38	for (table) \|*e, i\| {
41	39	var crc: I = i;
42		if (algorithm.refin) {
	40	if (algorithm.reflect_input) {
43	41	var j: usize = 0;
44	42	while (j < 8) : (j += 1) {
45	43	crc = (crc >> 1) ^ ((crc & 1) * poly);
...	...	@@ -59,10 +57,10 @@ pub fn Crc(comptime W: type, comptime algorithm: Algorithm(W)) type {
59	57	crc: I,
60	58
61	59	pub fn init() Self {
62		const initial = if (algorithm.refin)
63		@bitReverse(@as(I, algorithm.init)) >> (@bitSizeOf(I) - @bitSizeOf(W))
	60	const initial = if (algorithm.reflect_input)
	61	@bitReverse(@as(I, algorithm.initial)) >> (@bitSizeOf(I) - @bitSizeOf(W))
64	62	else
65		@as(I, algorithm.init) << (@bitSizeOf(I) - @bitSizeOf(W));
	63	@as(I, algorithm.initial) << (@bitSizeOf(I) - @bitSizeOf(W));
66	64	return Self{ .crc = initial };
67	65	}
68	66
...	...	@@ -76,7 +74,7 @@ pub fn Crc(comptime W: type, comptime algorithm: Algorithm(W)) type {
76	74	while (i < bytes.len) : (i += 1) {
77	75	self.crc = tableEntry(self.crc ^ bytes[i]);
78	76	}
79		} else if (algorithm.refin) {
	77	} else if (algorithm.reflect_input) {
80	78	while (i < bytes.len) : (i += 1) {
81	79	const table_index = self.crc ^ bytes[i];
82	80	self.crc = tableEntry(table_index) ^ (self.crc >> 8);
...	...	@@ -91,13 +89,13 @@ pub fn Crc(comptime W: type, comptime algorithm: Algorithm(W)) type {
91	89
92	90	pub fn final(self: Self) W {
93	91	var c = self.crc;
94		if (algorithm.refin != algorithm.refout) {
	92	if (algorithm.reflect_input != algorithm.reflect_output) {
95	93	c = @bitReverse(c);
96	94	}
97		if (!algorithm.refout) {
	95	if (!algorithm.reflect_output) {
98	96	c >>= @bitSizeOf(I) - @bitSizeOf(W);
99	97	}
100		return @intCast(W, c ^ algorithm.xorout);
	98	return @intCast(W, c ^ algorithm.xor_output);
101	99	}
102	100
103	101	pub fn hash(bytes: []const u8) W {

lib/std/hash/crc/catalog.zig+903-1463

...	...	@@ -1,1463 +1,903 @@
1		//! This file is auto-generated by tools/update_crc_catalog.sh.
2
3		const std = @import("../../std.zig");
4		const testing = std.testing;
5		const crc = @import("../crc.zig");
6		const Algorithm = crc.Algorithm;
7		const Crc = crc.Crc;
8
9		const crc_3_gsm: Algorithm(u3) = .{ .poly = 0x3, .init = 0x0, .refin = false, .refout = false, .xorout = 0x7, .check = 0x4, .residue = 0x2 };
10
11		pub const Crc3Gsm = Crc(u3, crc_3_gsm);
12
13		test "CRC-3/GSM" {
14		try testing.expectEqual(crc_3_gsm.check, Crc3Gsm.hash("123456789"));
15
16		var c = Crc3Gsm.init();
17		c.update("1234");
18		c.update("56789");
19		try testing.expectEqual(crc_3_gsm.check, c.final());
20		}
21
22		const crc_3_rohc: Algorithm(u3) = .{ .poly = 0x3, .init = 0x7, .refin = true, .refout = true, .xorout = 0x0, .check = 0x6, .residue = 0x0 };
23
24		pub const Crc3Rohc = Crc(u3, crc_3_rohc);
25
26		test "CRC-3/ROHC" {
27		try testing.expectEqual(crc_3_rohc.check, Crc3Rohc.hash("123456789"));
28
29		var c = Crc3Rohc.init();
30		c.update("1234");
31		c.update("56789");
32		try testing.expectEqual(crc_3_rohc.check, c.final());
33		}
34
35		const crc_4_g_704: Algorithm(u4) = .{ .poly = 0x3, .init = 0x0, .refin = true, .refout = true, .xorout = 0x0, .check = 0x7, .residue = 0x0 };
36
37		pub const Crc4G704 = Crc(u4, crc_4_g_704);
38
39		test "CRC-4/G-704" {
40		try testing.expectEqual(crc_4_g_704.check, Crc4G704.hash("123456789"));
41
42		var c = Crc4G704.init();
43		c.update("1234");
44		c.update("56789");
45		try testing.expectEqual(crc_4_g_704.check, c.final());
46		}
47
48		const crc_4_interlaken: Algorithm(u4) = .{ .poly = 0x3, .init = 0xf, .refin = false, .refout = false, .xorout = 0xf, .check = 0xb, .residue = 0x2 };
49
50		pub const Crc4Interlaken = Crc(u4, crc_4_interlaken);
51
52		test "CRC-4/INTERLAKEN" {
53		try testing.expectEqual(crc_4_interlaken.check, Crc4Interlaken.hash("123456789"));
54
55		var c = Crc4Interlaken.init();
56		c.update("1234");
57		c.update("56789");
58		try testing.expectEqual(crc_4_interlaken.check, c.final());
59		}
60
61		const crc_5_epc_c1g2: Algorithm(u5) = .{ .poly = 0x09, .init = 0x09, .refin = false, .refout = false, .xorout = 0x00, .check = 0x00, .residue = 0x00 };
62
63		pub const Crc5EpcC1g2 = Crc(u5, crc_5_epc_c1g2);
64
65		test "CRC-5/EPC-C1G2" {
66		try testing.expectEqual(crc_5_epc_c1g2.check, Crc5EpcC1g2.hash("123456789"));
67
68		var c = Crc5EpcC1g2.init();
69		c.update("1234");
70		c.update("56789");
71		try testing.expectEqual(crc_5_epc_c1g2.check, c.final());
72		}
73
74		const crc_5_g_704: Algorithm(u5) = .{ .poly = 0x15, .init = 0x00, .refin = true, .refout = true, .xorout = 0x00, .check = 0x07, .residue = 0x00 };
75
76		pub const Crc5G704 = Crc(u5, crc_5_g_704);
77
78		test "CRC-5/G-704" {
79		try testing.expectEqual(crc_5_g_704.check, Crc5G704.hash("123456789"));
80
81		var c = Crc5G704.init();
82		c.update("1234");
83		c.update("56789");
84		try testing.expectEqual(crc_5_g_704.check, c.final());
85		}
86
87		const crc_5_usb: Algorithm(u5) = .{ .poly = 0x05, .init = 0x1f, .refin = true, .refout = true, .xorout = 0x1f, .check = 0x19, .residue = 0x06 };
88
89		pub const Crc5Usb = Crc(u5, crc_5_usb);
90
91		test "CRC-5/USB" {
92		try testing.expectEqual(crc_5_usb.check, Crc5Usb.hash("123456789"));
93
94		var c = Crc5Usb.init();
95		c.update("1234");
96		c.update("56789");
97		try testing.expectEqual(crc_5_usb.check, c.final());
98		}
99
100		const crc_6_cdma2000_a: Algorithm(u6) = .{ .poly = 0x27, .init = 0x3f, .refin = false, .refout = false, .xorout = 0x00, .check = 0x0d, .residue = 0x00 };
101
102		pub const Crc6Cdma2000A = Crc(u6, crc_6_cdma2000_a);
103
104		test "CRC-6/CDMA2000-A" {
105		try testing.expectEqual(crc_6_cdma2000_a.check, Crc6Cdma2000A.hash("123456789"));
106
107		var c = Crc6Cdma2000A.init();
108		c.update("1234");
109		c.update("56789");
110		try testing.expectEqual(crc_6_cdma2000_a.check, c.final());
111		}
112
113		const crc_6_cdma2000_b: Algorithm(u6) = .{ .poly = 0x07, .init = 0x3f, .refin = false, .refout = false, .xorout = 0x00, .check = 0x3b, .residue = 0x00 };
114
115		pub const Crc6Cdma2000B = Crc(u6, crc_6_cdma2000_b);
116
117		test "CRC-6/CDMA2000-B" {
118		try testing.expectEqual(crc_6_cdma2000_b.check, Crc6Cdma2000B.hash("123456789"));
119
120		var c = Crc6Cdma2000B.init();
121		c.update("1234");
122		c.update("56789");
123		try testing.expectEqual(crc_6_cdma2000_b.check, c.final());
124		}
125
126		const crc_6_darc: Algorithm(u6) = .{ .poly = 0x19, .init = 0x00, .refin = true, .refout = true, .xorout = 0x00, .check = 0x26, .residue = 0x00 };
127
128		pub const Crc6Darc = Crc(u6, crc_6_darc);
129
130		test "CRC-6/DARC" {
131		try testing.expectEqual(crc_6_darc.check, Crc6Darc.hash("123456789"));
132
133		var c = Crc6Darc.init();
134		c.update("1234");
135		c.update("56789");
136		try testing.expectEqual(crc_6_darc.check, c.final());
137		}
138
139		const crc_6_g_704: Algorithm(u6) = .{ .poly = 0x03, .init = 0x00, .refin = true, .refout = true, .xorout = 0x00, .check = 0x06, .residue = 0x00 };
140
141		pub const Crc6G704 = Crc(u6, crc_6_g_704);
142
143		test "CRC-6/G-704" {
144		try testing.expectEqual(crc_6_g_704.check, Crc6G704.hash("123456789"));
145
146		var c = Crc6G704.init();
147		c.update("1234");
148		c.update("56789");
149		try testing.expectEqual(crc_6_g_704.check, c.final());
150		}
151
152		const crc_6_gsm: Algorithm(u6) = .{ .poly = 0x2f, .init = 0x00, .refin = false, .refout = false, .xorout = 0x3f, .check = 0x13, .residue = 0x3a };
153
154		pub const Crc6Gsm = Crc(u6, crc_6_gsm);
155
156		test "CRC-6/GSM" {
157		try testing.expectEqual(crc_6_gsm.check, Crc6Gsm.hash("123456789"));
158
159		var c = Crc6Gsm.init();
160		c.update("1234");
161		c.update("56789");
162		try testing.expectEqual(crc_6_gsm.check, c.final());
163		}
164
165		const crc_7_mmc: Algorithm(u7) = .{ .poly = 0x09, .init = 0x00, .refin = false, .refout = false, .xorout = 0x00, .check = 0x75, .residue = 0x00 };
166
167		pub const Crc7Mmc = Crc(u7, crc_7_mmc);
168
169		test "CRC-7/MMC" {
170		try testing.expectEqual(crc_7_mmc.check, Crc7Mmc.hash("123456789"));
171
172		var c = Crc7Mmc.init();
173		c.update("1234");
174		c.update("56789");
175		try testing.expectEqual(crc_7_mmc.check, c.final());
176		}
177
178		const crc_7_rohc: Algorithm(u7) = .{ .poly = 0x4f, .init = 0x7f, .refin = true, .refout = true, .xorout = 0x00, .check = 0x53, .residue = 0x00 };
179
180		pub const Crc7Rohc = Crc(u7, crc_7_rohc);
181
182		test "CRC-7/ROHC" {
183		try testing.expectEqual(crc_7_rohc.check, Crc7Rohc.hash("123456789"));
184
185		var c = Crc7Rohc.init();
186		c.update("1234");
187		c.update("56789");
188		try testing.expectEqual(crc_7_rohc.check, c.final());
189		}
190
191		const crc_7_umts: Algorithm(u7) = .{ .poly = 0x45, .init = 0x00, .refin = false, .refout = false, .xorout = 0x00, .check = 0x61, .residue = 0x00 };
192
193		pub const Crc7Umts = Crc(u7, crc_7_umts);
194
195		test "CRC-7/UMTS" {
196		try testing.expectEqual(crc_7_umts.check, Crc7Umts.hash("123456789"));
197
198		var c = Crc7Umts.init();
199		c.update("1234");
200		c.update("56789");
201		try testing.expectEqual(crc_7_umts.check, c.final());
202		}
203
204		const crc_8_autosar: Algorithm(u8) = .{ .poly = 0x2f, .init = 0xff, .refin = false, .refout = false, .xorout = 0xff, .check = 0xdf, .residue = 0x42 };
205
206		pub const Crc8Autosar = Crc(u8, crc_8_autosar);
207
208		test "CRC-8/AUTOSAR" {
209		try testing.expectEqual(crc_8_autosar.check, Crc8Autosar.hash("123456789"));
210
211		var c = Crc8Autosar.init();
212		c.update("1234");
213		c.update("56789");
214		try testing.expectEqual(crc_8_autosar.check, c.final());
215		}
216
217		const crc_8_bluetooth: Algorithm(u8) = .{ .poly = 0xa7, .init = 0x00, .refin = true, .refout = true, .xorout = 0x00, .check = 0x26, .residue = 0x00 };
218
219		pub const Crc8Bluetooth = Crc(u8, crc_8_bluetooth);
220
221		test "CRC-8/BLUETOOTH" {
222		try testing.expectEqual(crc_8_bluetooth.check, Crc8Bluetooth.hash("123456789"));
223
224		var c = Crc8Bluetooth.init();
225		c.update("1234");
226		c.update("56789");
227		try testing.expectEqual(crc_8_bluetooth.check, c.final());
228		}
229
230		const crc_8_cdma2000: Algorithm(u8) = .{ .poly = 0x9b, .init = 0xff, .refin = false, .refout = false, .xorout = 0x00, .check = 0xda, .residue = 0x00 };
231
232		pub const Crc8Cdma2000 = Crc(u8, crc_8_cdma2000);
233
234		test "CRC-8/CDMA2000" {
235		try testing.expectEqual(crc_8_cdma2000.check, Crc8Cdma2000.hash("123456789"));
236
237		var c = Crc8Cdma2000.init();
238		c.update("1234");
239		c.update("56789");
240		try testing.expectEqual(crc_8_cdma2000.check, c.final());
241		}
242
243		const crc_8_darc: Algorithm(u8) = .{ .poly = 0x39, .init = 0x00, .refin = true, .refout = true, .xorout = 0x00, .check = 0x15, .residue = 0x00 };
244
245		pub const Crc8Darc = Crc(u8, crc_8_darc);
246
247		test "CRC-8/DARC" {
248		try testing.expectEqual(crc_8_darc.check, Crc8Darc.hash("123456789"));
249
250		var c = Crc8Darc.init();
251		c.update("1234");
252		c.update("56789");
253		try testing.expectEqual(crc_8_darc.check, c.final());
254		}
255
256		const crc_8_dvb_s2: Algorithm(u8) = .{ .poly = 0xd5, .init = 0x00, .refin = false, .refout = false, .xorout = 0x00, .check = 0xbc, .residue = 0x00 };
257
258		pub const Crc8DvbS2 = Crc(u8, crc_8_dvb_s2);
259
260		test "CRC-8/DVB-S2" {
261		try testing.expectEqual(crc_8_dvb_s2.check, Crc8DvbS2.hash("123456789"));
262
263		var c = Crc8DvbS2.init();
264		c.update("1234");
265		c.update("56789");
266		try testing.expectEqual(crc_8_dvb_s2.check, c.final());
267		}
268
269		const crc_8_gsm_a: Algorithm(u8) = .{ .poly = 0x1d, .init = 0x00, .refin = false, .refout = false, .xorout = 0x00, .check = 0x37, .residue = 0x00 };
270
271		pub const Crc8GsmA = Crc(u8, crc_8_gsm_a);
272
273		test "CRC-8/GSM-A" {
274		try testing.expectEqual(crc_8_gsm_a.check, Crc8GsmA.hash("123456789"));
275
276		var c = Crc8GsmA.init();
277		c.update("1234");
278		c.update("56789");
279		try testing.expectEqual(crc_8_gsm_a.check, c.final());
280		}
281
282		const crc_8_gsm_b: Algorithm(u8) = .{ .poly = 0x49, .init = 0x00, .refin = false, .refout = false, .xorout = 0xff, .check = 0x94, .residue = 0x53 };
283
284		pub const Crc8GsmB = Crc(u8, crc_8_gsm_b);
285
286		test "CRC-8/GSM-B" {
287		try testing.expectEqual(crc_8_gsm_b.check, Crc8GsmB.hash("123456789"));
288
289		var c = Crc8GsmB.init();
290		c.update("1234");
291		c.update("56789");
292		try testing.expectEqual(crc_8_gsm_b.check, c.final());
293		}
294
295		const crc_8_hitag: Algorithm(u8) = .{ .poly = 0x1d, .init = 0xff, .refin = false, .refout = false, .xorout = 0x00, .check = 0xb4, .residue = 0x00 };
296
297		pub const Crc8Hitag = Crc(u8, crc_8_hitag);
298
299		test "CRC-8/HITAG" {
300		try testing.expectEqual(crc_8_hitag.check, Crc8Hitag.hash("123456789"));
301
302		var c = Crc8Hitag.init();
303		c.update("1234");
304		c.update("56789");
305		try testing.expectEqual(crc_8_hitag.check, c.final());
306		}
307
308		const crc_8_i_432_1: Algorithm(u8) = .{ .poly = 0x07, .init = 0x00, .refin = false, .refout = false, .xorout = 0x55, .check = 0xa1, .residue = 0xac };
309
310		pub const Crc8I4321 = Crc(u8, crc_8_i_432_1);
311
312		test "CRC-8/I-432-1" {
313		try testing.expectEqual(crc_8_i_432_1.check, Crc8I4321.hash("123456789"));
314
315		var c = Crc8I4321.init();
316		c.update("1234");
317		c.update("56789");
318		try testing.expectEqual(crc_8_i_432_1.check, c.final());
319		}
320
321		const crc_8_i_code: Algorithm(u8) = .{ .poly = 0x1d, .init = 0xfd, .refin = false, .refout = false, .xorout = 0x00, .check = 0x7e, .residue = 0x00 };
322
323		pub const Crc8ICode = Crc(u8, crc_8_i_code);
324
325		test "CRC-8/I-CODE" {
326		try testing.expectEqual(crc_8_i_code.check, Crc8ICode.hash("123456789"));
327
328		var c = Crc8ICode.init();
329		c.update("1234");
330		c.update("56789");
331		try testing.expectEqual(crc_8_i_code.check, c.final());
332		}
333
334		const crc_8_lte: Algorithm(u8) = .{ .poly = 0x9b, .init = 0x00, .refin = false, .refout = false, .xorout = 0x00, .check = 0xea, .residue = 0x00 };
335
336		pub const Crc8Lte = Crc(u8, crc_8_lte);
337
338		test "CRC-8/LTE" {
339		try testing.expectEqual(crc_8_lte.check, Crc8Lte.hash("123456789"));
340
341		var c = Crc8Lte.init();
342		c.update("1234");
343		c.update("56789");
344		try testing.expectEqual(crc_8_lte.check, c.final());
345		}
346
347		const crc_8_maxim_dow: Algorithm(u8) = .{ .poly = 0x31, .init = 0x00, .refin = true, .refout = true, .xorout = 0x00, .check = 0xa1, .residue = 0x00 };
348
349		pub const Crc8MaximDow = Crc(u8, crc_8_maxim_dow);
350
351		test "CRC-8/MAXIM-DOW" {
352		try testing.expectEqual(crc_8_maxim_dow.check, Crc8MaximDow.hash("123456789"));
353
354		var c = Crc8MaximDow.init();
355		c.update("1234");
356		c.update("56789");
357		try testing.expectEqual(crc_8_maxim_dow.check, c.final());
358		}
359
360		const crc_8_mifare_mad: Algorithm(u8) = .{ .poly = 0x1d, .init = 0xc7, .refin = false, .refout = false, .xorout = 0x00, .check = 0x99, .residue = 0x00 };
361
362		pub const Crc8MifareMad = Crc(u8, crc_8_mifare_mad);
363
364		test "CRC-8/MIFARE-MAD" {
365		try testing.expectEqual(crc_8_mifare_mad.check, Crc8MifareMad.hash("123456789"));
366
367		var c = Crc8MifareMad.init();
368		c.update("1234");
369		c.update("56789");
370		try testing.expectEqual(crc_8_mifare_mad.check, c.final());
371		}
372
373		const crc_8_nrsc_5: Algorithm(u8) = .{ .poly = 0x31, .init = 0xff, .refin = false, .refout = false, .xorout = 0x00, .check = 0xf7, .residue = 0x00 };
374
375		pub const Crc8Nrsc5 = Crc(u8, crc_8_nrsc_5);
376
377		test "CRC-8/NRSC-5" {
378		try testing.expectEqual(crc_8_nrsc_5.check, Crc8Nrsc5.hash("123456789"));
379
380		var c = Crc8Nrsc5.init();
381		c.update("1234");
382		c.update("56789");
383		try testing.expectEqual(crc_8_nrsc_5.check, c.final());
384		}
385
386		const crc_8_opensafety: Algorithm(u8) = .{ .poly = 0x2f, .init = 0x00, .refin = false, .refout = false, .xorout = 0x00, .check = 0x3e, .residue = 0x00 };
387
388		pub const Crc8Opensafety = Crc(u8, crc_8_opensafety);
389
390		test "CRC-8/OPENSAFETY" {
391		try testing.expectEqual(crc_8_opensafety.check, Crc8Opensafety.hash("123456789"));
392
393		var c = Crc8Opensafety.init();
394		c.update("1234");
395		c.update("56789");
396		try testing.expectEqual(crc_8_opensafety.check, c.final());
397		}
398
399		const crc_8_rohc: Algorithm(u8) = .{ .poly = 0x07, .init = 0xff, .refin = true, .refout = true, .xorout = 0x00, .check = 0xd0, .residue = 0x00 };
400
401		pub const Crc8Rohc = Crc(u8, crc_8_rohc);
402
403		test "CRC-8/ROHC" {
404		try testing.expectEqual(crc_8_rohc.check, Crc8Rohc.hash("123456789"));
405
406		var c = Crc8Rohc.init();
407		c.update("1234");
408		c.update("56789");
409		try testing.expectEqual(crc_8_rohc.check, c.final());
410		}
411
412		const crc_8_sae_j1850: Algorithm(u8) = .{ .poly = 0x1d, .init = 0xff, .refin = false, .refout = false, .xorout = 0xff, .check = 0x4b, .residue = 0xc4 };
413
414		pub const Crc8SaeJ1850 = Crc(u8, crc_8_sae_j1850);
415
416		test "CRC-8/SAE-J1850" {
417		try testing.expectEqual(crc_8_sae_j1850.check, Crc8SaeJ1850.hash("123456789"));
418
419		var c = Crc8SaeJ1850.init();
420		c.update("1234");
421		c.update("56789");
422		try testing.expectEqual(crc_8_sae_j1850.check, c.final());
423		}
424
425		const crc_8_smbus: Algorithm(u8) = .{ .poly = 0x07, .init = 0x00, .refin = false, .refout = false, .xorout = 0x00, .check = 0xf4, .residue = 0x00 };
426
427		pub const Crc8Smbus = Crc(u8, crc_8_smbus);
428
429		test "CRC-8/SMBUS" {
430		try testing.expectEqual(crc_8_smbus.check, Crc8Smbus.hash("123456789"));
431
432		var c = Crc8Smbus.init();
433		c.update("1234");
434		c.update("56789");
435		try testing.expectEqual(crc_8_smbus.check, c.final());
436		}
437
438		const crc_8_tech_3250: Algorithm(u8) = .{ .poly = 0x1d, .init = 0xff, .refin = true, .refout = true, .xorout = 0x00, .check = 0x97, .residue = 0x00 };
439
440		pub const Crc8Tech3250 = Crc(u8, crc_8_tech_3250);
441
442		test "CRC-8/TECH-3250" {
443		try testing.expectEqual(crc_8_tech_3250.check, Crc8Tech3250.hash("123456789"));
444
445		var c = Crc8Tech3250.init();
446		c.update("1234");
447		c.update("56789");
448		try testing.expectEqual(crc_8_tech_3250.check, c.final());
449		}
450
451		const crc_8_wcdma: Algorithm(u8) = .{ .poly = 0x9b, .init = 0x00, .refin = true, .refout = true, .xorout = 0x00, .check = 0x25, .residue = 0x00 };
452
453		pub const Crc8Wcdma = Crc(u8, crc_8_wcdma);
454
455		test "CRC-8/WCDMA" {
456		try testing.expectEqual(crc_8_wcdma.check, Crc8Wcdma.hash("123456789"));
457
458		var c = Crc8Wcdma.init();
459		c.update("1234");
460		c.update("56789");
461		try testing.expectEqual(crc_8_wcdma.check, c.final());
462		}
463
464		const crc_10_atm: Algorithm(u10) = .{ .poly = 0x233, .init = 0x000, .refin = false, .refout = false, .xorout = 0x000, .check = 0x199, .residue = 0x000 };
465
466		pub const Crc10Atm = Crc(u10, crc_10_atm);
467
468		test "CRC-10/ATM" {
469		try testing.expectEqual(crc_10_atm.check, Crc10Atm.hash("123456789"));
470
471		var c = Crc10Atm.init();
472		c.update("1234");
473		c.update("56789");
474		try testing.expectEqual(crc_10_atm.check, c.final());
475		}
476
477		const crc_10_cdma2000: Algorithm(u10) = .{ .poly = 0x3d9, .init = 0x3ff, .refin = false, .refout = false, .xorout = 0x000, .check = 0x233, .residue = 0x000 };
478
479		pub const Crc10Cdma2000 = Crc(u10, crc_10_cdma2000);
480
481		test "CRC-10/CDMA2000" {
482		try testing.expectEqual(crc_10_cdma2000.check, Crc10Cdma2000.hash("123456789"));
483
484		var c = Crc10Cdma2000.init();
485		c.update("1234");
486		c.update("56789");
487		try testing.expectEqual(crc_10_cdma2000.check, c.final());
488		}
489
490		const crc_10_gsm: Algorithm(u10) = .{ .poly = 0x175, .init = 0x000, .refin = false, .refout = false, .xorout = 0x3ff, .check = 0x12a, .residue = 0x0c6 };
491
492		pub const Crc10Gsm = Crc(u10, crc_10_gsm);
493
494		test "CRC-10/GSM" {
495		try testing.expectEqual(crc_10_gsm.check, Crc10Gsm.hash("123456789"));
496
497		var c = Crc10Gsm.init();
498		c.update("1234");
499		c.update("56789");
500		try testing.expectEqual(crc_10_gsm.check, c.final());
501		}
502
503		const crc_11_flexray: Algorithm(u11) = .{ .poly = 0x385, .init = 0x01a, .refin = false, .refout = false, .xorout = 0x000, .check = 0x5a3, .residue = 0x000 };
504
505		pub const Crc11Flexray = Crc(u11, crc_11_flexray);
506
507		test "CRC-11/FLEXRAY" {
508		try testing.expectEqual(crc_11_flexray.check, Crc11Flexray.hash("123456789"));
509
510		var c = Crc11Flexray.init();
511		c.update("1234");
512		c.update("56789");
513		try testing.expectEqual(crc_11_flexray.check, c.final());
514		}
515
516		const crc_11_umts: Algorithm(u11) = .{ .poly = 0x307, .init = 0x000, .refin = false, .refout = false, .xorout = 0x000, .check = 0x061, .residue = 0x000 };
517
518		pub const Crc11Umts = Crc(u11, crc_11_umts);
519
520		test "CRC-11/UMTS" {
521		try testing.expectEqual(crc_11_umts.check, Crc11Umts.hash("123456789"));
522
523		var c = Crc11Umts.init();
524		c.update("1234");
525		c.update("56789");
526		try testing.expectEqual(crc_11_umts.check, c.final());
527		}
528
529		const crc_12_cdma2000: Algorithm(u12) = .{ .poly = 0xf13, .init = 0xfff, .refin = false, .refout = false, .xorout = 0x000, .check = 0xd4d, .residue = 0x000 };
530
531		pub const Crc12Cdma2000 = Crc(u12, crc_12_cdma2000);
532
533		test "CRC-12/CDMA2000" {
534		try testing.expectEqual(crc_12_cdma2000.check, Crc12Cdma2000.hash("123456789"));
535
536		var c = Crc12Cdma2000.init();
537		c.update("1234");
538		c.update("56789");
539		try testing.expectEqual(crc_12_cdma2000.check, c.final());
540		}
541
542		const crc_12_dect: Algorithm(u12) = .{ .poly = 0x80f, .init = 0x000, .refin = false, .refout = false, .xorout = 0x000, .check = 0xf5b, .residue = 0x000 };
543
544		pub const Crc12Dect = Crc(u12, crc_12_dect);
545
546		test "CRC-12/DECT" {
547		try testing.expectEqual(crc_12_dect.check, Crc12Dect.hash("123456789"));
548
549		var c = Crc12Dect.init();
550		c.update("1234");
551		c.update("56789");
552		try testing.expectEqual(crc_12_dect.check, c.final());
553		}
554
555		const crc_12_gsm: Algorithm(u12) = .{ .poly = 0xd31, .init = 0x000, .refin = false, .refout = false, .xorout = 0xfff, .check = 0xb34, .residue = 0x178 };
556
557		pub const Crc12Gsm = Crc(u12, crc_12_gsm);
558
559		test "CRC-12/GSM" {
560		try testing.expectEqual(crc_12_gsm.check, Crc12Gsm.hash("123456789"));
561
562		var c = Crc12Gsm.init();
563		c.update("1234");
564		c.update("56789");
565		try testing.expectEqual(crc_12_gsm.check, c.final());
566		}
567
568		const crc_12_umts: Algorithm(u12) = .{ .poly = 0x80f, .init = 0x000, .refin = false, .refout = true, .xorout = 0x000, .check = 0xdaf, .residue = 0x000 };
569
570		pub const Crc12Umts = Crc(u12, crc_12_umts);
571
572		test "CRC-12/UMTS" {
573		try testing.expectEqual(crc_12_umts.check, Crc12Umts.hash("123456789"));
574
575		var c = Crc12Umts.init();
576		c.update("1234");
577		c.update("56789");
578		try testing.expectEqual(crc_12_umts.check, c.final());
579		}
580
581		const crc_13_bbc: Algorithm(u13) = .{ .poly = 0x1cf5, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x04fa, .residue = 0x0000 };
582
583		pub const Crc13Bbc = Crc(u13, crc_13_bbc);
584
585		test "CRC-13/BBC" {
586		try testing.expectEqual(crc_13_bbc.check, Crc13Bbc.hash("123456789"));
587
588		var c = Crc13Bbc.init();
589		c.update("1234");
590		c.update("56789");
591		try testing.expectEqual(crc_13_bbc.check, c.final());
592		}
593
594		const crc_14_darc: Algorithm(u14) = .{ .poly = 0x0805, .init = 0x0000, .refin = true, .refout = true, .xorout = 0x0000, .check = 0x082d, .residue = 0x0000 };
595
596		pub const Crc14Darc = Crc(u14, crc_14_darc);
597
598		test "CRC-14/DARC" {
599		try testing.expectEqual(crc_14_darc.check, Crc14Darc.hash("123456789"));
600
601		var c = Crc14Darc.init();
602		c.update("1234");
603		c.update("56789");
604		try testing.expectEqual(crc_14_darc.check, c.final());
605		}
606
607		const crc_14_gsm: Algorithm(u14) = .{ .poly = 0x202d, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x3fff, .check = 0x30ae, .residue = 0x031e };
608
609		pub const Crc14Gsm = Crc(u14, crc_14_gsm);
610
611		test "CRC-14/GSM" {
612		try testing.expectEqual(crc_14_gsm.check, Crc14Gsm.hash("123456789"));
613
614		var c = Crc14Gsm.init();
615		c.update("1234");
616		c.update("56789");
617		try testing.expectEqual(crc_14_gsm.check, c.final());
618		}
619
620		const crc_15_can: Algorithm(u15) = .{ .poly = 0x4599, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x059e, .residue = 0x0000 };
621
622		pub const Crc15Can = Crc(u15, crc_15_can);
623
624		test "CRC-15/CAN" {
625		try testing.expectEqual(crc_15_can.check, Crc15Can.hash("123456789"));
626
627		var c = Crc15Can.init();
628		c.update("1234");
629		c.update("56789");
630		try testing.expectEqual(crc_15_can.check, c.final());
631		}
632
633		const crc_15_mpt1327: Algorithm(u15) = .{ .poly = 0x6815, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0001, .check = 0x2566, .residue = 0x6815 };
634
635		pub const Crc15Mpt1327 = Crc(u15, crc_15_mpt1327);
636
637		test "CRC-15/MPT1327" {
638		try testing.expectEqual(crc_15_mpt1327.check, Crc15Mpt1327.hash("123456789"));
639
640		var c = Crc15Mpt1327.init();
641		c.update("1234");
642		c.update("56789");
643		try testing.expectEqual(crc_15_mpt1327.check, c.final());
644		}
645
646		const crc_16_arc: Algorithm(u16) = .{ .poly = 0x8005, .init = 0x0000, .refin = true, .refout = true, .xorout = 0x0000, .check = 0xbb3d, .residue = 0x0000 };
647
648		pub const Crc16Arc = Crc(u16, crc_16_arc);
649
650		test "CRC-16/ARC" {
651		try testing.expectEqual(crc_16_arc.check, Crc16Arc.hash("123456789"));
652
653		var c = Crc16Arc.init();
654		c.update("1234");
655		c.update("56789");
656		try testing.expectEqual(crc_16_arc.check, c.final());
657		}
658
659		const crc_16_cdma2000: Algorithm(u16) = .{ .poly = 0xc867, .init = 0xffff, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x4c06, .residue = 0x0000 };
660
661		pub const Crc16Cdma2000 = Crc(u16, crc_16_cdma2000);
662
663		test "CRC-16/CDMA2000" {
664		try testing.expectEqual(crc_16_cdma2000.check, Crc16Cdma2000.hash("123456789"));
665
666		var c = Crc16Cdma2000.init();
667		c.update("1234");
668		c.update("56789");
669		try testing.expectEqual(crc_16_cdma2000.check, c.final());
670		}
671
672		const crc_16_cms: Algorithm(u16) = .{ .poly = 0x8005, .init = 0xffff, .refin = false, .refout = false, .xorout = 0x0000, .check = 0xaee7, .residue = 0x0000 };
673
674		pub const Crc16Cms = Crc(u16, crc_16_cms);
675
676		test "CRC-16/CMS" {
677		try testing.expectEqual(crc_16_cms.check, Crc16Cms.hash("123456789"));
678
679		var c = Crc16Cms.init();
680		c.update("1234");
681		c.update("56789");
682		try testing.expectEqual(crc_16_cms.check, c.final());
683		}
684
685		const crc_16_dds_110: Algorithm(u16) = .{ .poly = 0x8005, .init = 0x800d, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x9ecf, .residue = 0x0000 };
686
687		pub const Crc16Dds110 = Crc(u16, crc_16_dds_110);
688
689		test "CRC-16/DDS-110" {
690		try testing.expectEqual(crc_16_dds_110.check, Crc16Dds110.hash("123456789"));
691
692		var c = Crc16Dds110.init();
693		c.update("1234");
694		c.update("56789");
695		try testing.expectEqual(crc_16_dds_110.check, c.final());
696		}
697
698		const crc_16_dect_r: Algorithm(u16) = .{ .poly = 0x0589, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0001, .check = 0x007e, .residue = 0x0589 };
699
700		pub const Crc16DectR = Crc(u16, crc_16_dect_r);
701
702		test "CRC-16/DECT-R" {
703		try testing.expectEqual(crc_16_dect_r.check, Crc16DectR.hash("123456789"));
704
705		var c = Crc16DectR.init();
706		c.update("1234");
707		c.update("56789");
708		try testing.expectEqual(crc_16_dect_r.check, c.final());
709		}
710
711		const crc_16_dect_x: Algorithm(u16) = .{ .poly = 0x0589, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x007f, .residue = 0x0000 };
712
713		pub const Crc16DectX = Crc(u16, crc_16_dect_x);
714
715		test "CRC-16/DECT-X" {
716		try testing.expectEqual(crc_16_dect_x.check, Crc16DectX.hash("123456789"));
717
718		var c = Crc16DectX.init();
719		c.update("1234");
720		c.update("56789");
721		try testing.expectEqual(crc_16_dect_x.check, c.final());
722		}
723
724		const crc_16_dnp: Algorithm(u16) = .{ .poly = 0x3d65, .init = 0x0000, .refin = true, .refout = true, .xorout = 0xffff, .check = 0xea82, .residue = 0x66c5 };
725
726		pub const Crc16Dnp = Crc(u16, crc_16_dnp);
727
728		test "CRC-16/DNP" {
729		try testing.expectEqual(crc_16_dnp.check, Crc16Dnp.hash("123456789"));
730
731		var c = Crc16Dnp.init();
732		c.update("1234");
733		c.update("56789");
734		try testing.expectEqual(crc_16_dnp.check, c.final());
735		}
736
737		const crc_16_en_13757: Algorithm(u16) = .{ .poly = 0x3d65, .init = 0x0000, .refin = false, .refout = false, .xorout = 0xffff, .check = 0xc2b7, .residue = 0xa366 };
738
739		pub const Crc16En13757 = Crc(u16, crc_16_en_13757);
740
741		test "CRC-16/EN-13757" {
742		try testing.expectEqual(crc_16_en_13757.check, Crc16En13757.hash("123456789"));
743
744		var c = Crc16En13757.init();
745		c.update("1234");
746		c.update("56789");
747		try testing.expectEqual(crc_16_en_13757.check, c.final());
748		}
749
750		const crc_16_genibus: Algorithm(u16) = .{ .poly = 0x1021, .init = 0xffff, .refin = false, .refout = false, .xorout = 0xffff, .check = 0xd64e, .residue = 0x1d0f };
751
752		pub const Crc16Genibus = Crc(u16, crc_16_genibus);
753
754		test "CRC-16/GENIBUS" {
755		try testing.expectEqual(crc_16_genibus.check, Crc16Genibus.hash("123456789"));
756
757		var c = Crc16Genibus.init();
758		c.update("1234");
759		c.update("56789");
760		try testing.expectEqual(crc_16_genibus.check, c.final());
761		}
762
763		const crc_16_gsm: Algorithm(u16) = .{ .poly = 0x1021, .init = 0x0000, .refin = false, .refout = false, .xorout = 0xffff, .check = 0xce3c, .residue = 0x1d0f };
764
765		pub const Crc16Gsm = Crc(u16, crc_16_gsm);
766
767		test "CRC-16/GSM" {
768		try testing.expectEqual(crc_16_gsm.check, Crc16Gsm.hash("123456789"));
769
770		var c = Crc16Gsm.init();
771		c.update("1234");
772		c.update("56789");
773		try testing.expectEqual(crc_16_gsm.check, c.final());
774		}
775
776		const crc_16_ibm_3740: Algorithm(u16) = .{ .poly = 0x1021, .init = 0xffff, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x29b1, .residue = 0x0000 };
777
778		pub const Crc16Ibm3740 = Crc(u16, crc_16_ibm_3740);
779
780		test "CRC-16/IBM-3740" {
781		try testing.expectEqual(crc_16_ibm_3740.check, Crc16Ibm3740.hash("123456789"));
782
783		var c = Crc16Ibm3740.init();
784		c.update("1234");
785		c.update("56789");
786		try testing.expectEqual(crc_16_ibm_3740.check, c.final());
787		}
788
789		const crc_16_ibm_sdlc: Algorithm(u16) = .{ .poly = 0x1021, .init = 0xffff, .refin = true, .refout = true, .xorout = 0xffff, .check = 0x906e, .residue = 0xf0b8 };
790
791		pub const Crc16IbmSdlc = Crc(u16, crc_16_ibm_sdlc);
792
793		test "CRC-16/IBM-SDLC" {
794		try testing.expectEqual(crc_16_ibm_sdlc.check, Crc16IbmSdlc.hash("123456789"));
795
796		var c = Crc16IbmSdlc.init();
797		c.update("1234");
798		c.update("56789");
799		try testing.expectEqual(crc_16_ibm_sdlc.check, c.final());
800		}
801
802		const crc_16_iso_iec_14443_3_a: Algorithm(u16) = .{ .poly = 0x1021, .init = 0xc6c6, .refin = true, .refout = true, .xorout = 0x0000, .check = 0xbf05, .residue = 0x0000 };
803
804		pub const Crc16IsoIec144433A = Crc(u16, crc_16_iso_iec_14443_3_a);
805
806		test "CRC-16/ISO-IEC-14443-3-A" {
807		try testing.expectEqual(crc_16_iso_iec_14443_3_a.check, Crc16IsoIec144433A.hash("123456789"));
808
809		var c = Crc16IsoIec144433A.init();
810		c.update("1234");
811		c.update("56789");
812		try testing.expectEqual(crc_16_iso_iec_14443_3_a.check, c.final());
813		}
814
815		const crc_16_kermit: Algorithm(u16) = .{ .poly = 0x1021, .init = 0x0000, .refin = true, .refout = true, .xorout = 0x0000, .check = 0x2189, .residue = 0x0000 };
816
817		pub const Crc16Kermit = Crc(u16, crc_16_kermit);
818
819		test "CRC-16/KERMIT" {
820		try testing.expectEqual(crc_16_kermit.check, Crc16Kermit.hash("123456789"));
821
822		var c = Crc16Kermit.init();
823		c.update("1234");
824		c.update("56789");
825		try testing.expectEqual(crc_16_kermit.check, c.final());
826		}
827
828		const crc_16_lj1200: Algorithm(u16) = .{ .poly = 0x6f63, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0xbdf4, .residue = 0x0000 };
829
830		pub const Crc16Lj1200 = Crc(u16, crc_16_lj1200);
831
832		test "CRC-16/LJ1200" {
833		try testing.expectEqual(crc_16_lj1200.check, Crc16Lj1200.hash("123456789"));
834
835		var c = Crc16Lj1200.init();
836		c.update("1234");
837		c.update("56789");
838		try testing.expectEqual(crc_16_lj1200.check, c.final());
839		}
840
841		const crc_16_m17: Algorithm(u16) = .{ .poly = 0x5935, .init = 0xffff, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x772b, .residue = 0x0000 };
842
843		pub const Crc16M17 = Crc(u16, crc_16_m17);
844
845		test "CRC-16/M17" {
846		try testing.expectEqual(crc_16_m17.check, Crc16M17.hash("123456789"));
847
848		var c = Crc16M17.init();
849		c.update("1234");
850		c.update("56789");
851		try testing.expectEqual(crc_16_m17.check, c.final());
852		}
853
854		const crc_16_maxim_dow: Algorithm(u16) = .{ .poly = 0x8005, .init = 0x0000, .refin = true, .refout = true, .xorout = 0xffff, .check = 0x44c2, .residue = 0xb001 };
855
856		pub const Crc16MaximDow = Crc(u16, crc_16_maxim_dow);
857
858		test "CRC-16/MAXIM-DOW" {
859		try testing.expectEqual(crc_16_maxim_dow.check, Crc16MaximDow.hash("123456789"));
860
861		var c = Crc16MaximDow.init();
862		c.update("1234");
863		c.update("56789");
864		try testing.expectEqual(crc_16_maxim_dow.check, c.final());
865		}
866
867		const crc_16_mcrf4xx: Algorithm(u16) = .{ .poly = 0x1021, .init = 0xffff, .refin = true, .refout = true, .xorout = 0x0000, .check = 0x6f91, .residue = 0x0000 };
868
869		pub const Crc16Mcrf4xx = Crc(u16, crc_16_mcrf4xx);
870
871		test "CRC-16/MCRF4XX" {
872		try testing.expectEqual(crc_16_mcrf4xx.check, Crc16Mcrf4xx.hash("123456789"));
873
874		var c = Crc16Mcrf4xx.init();
875		c.update("1234");
876		c.update("56789");
877		try testing.expectEqual(crc_16_mcrf4xx.check, c.final());
878		}
879
880		const crc_16_modbus: Algorithm(u16) = .{ .poly = 0x8005, .init = 0xffff, .refin = true, .refout = true, .xorout = 0x0000, .check = 0x4b37, .residue = 0x0000 };
881
882		pub const Crc16Modbus = Crc(u16, crc_16_modbus);
883
884		test "CRC-16/MODBUS" {
885		try testing.expectEqual(crc_16_modbus.check, Crc16Modbus.hash("123456789"));
886
887		var c = Crc16Modbus.init();
888		c.update("1234");
889		c.update("56789");
890		try testing.expectEqual(crc_16_modbus.check, c.final());
891		}
892
893		const crc_16_nrsc_5: Algorithm(u16) = .{ .poly = 0x080b, .init = 0xffff, .refin = true, .refout = true, .xorout = 0x0000, .check = 0xa066, .residue = 0x0000 };
894
895		pub const Crc16Nrsc5 = Crc(u16, crc_16_nrsc_5);
896
897		test "CRC-16/NRSC-5" {
898		try testing.expectEqual(crc_16_nrsc_5.check, Crc16Nrsc5.hash("123456789"));
899
900		var c = Crc16Nrsc5.init();
901		c.update("1234");
902		c.update("56789");
903		try testing.expectEqual(crc_16_nrsc_5.check, c.final());
904		}
905
906		const crc_16_opensafety_a: Algorithm(u16) = .{ .poly = 0x5935, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x5d38, .residue = 0x0000 };
907
908		pub const Crc16OpensafetyA = Crc(u16, crc_16_opensafety_a);
909
910		test "CRC-16/OPENSAFETY-A" {
911		try testing.expectEqual(crc_16_opensafety_a.check, Crc16OpensafetyA.hash("123456789"));
912
913		var c = Crc16OpensafetyA.init();
914		c.update("1234");
915		c.update("56789");
916		try testing.expectEqual(crc_16_opensafety_a.check, c.final());
917		}
918
919		const crc_16_opensafety_b: Algorithm(u16) = .{ .poly = 0x755b, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x20fe, .residue = 0x0000 };
920
921		pub const Crc16OpensafetyB = Crc(u16, crc_16_opensafety_b);
922
923		test "CRC-16/OPENSAFETY-B" {
924		try testing.expectEqual(crc_16_opensafety_b.check, Crc16OpensafetyB.hash("123456789"));
925
926		var c = Crc16OpensafetyB.init();
927		c.update("1234");
928		c.update("56789");
929		try testing.expectEqual(crc_16_opensafety_b.check, c.final());
930		}
931
932		const crc_16_profibus: Algorithm(u16) = .{ .poly = 0x1dcf, .init = 0xffff, .refin = false, .refout = false, .xorout = 0xffff, .check = 0xa819, .residue = 0xe394 };
933
934		pub const Crc16Profibus = Crc(u16, crc_16_profibus);
935
936		test "CRC-16/PROFIBUS" {
937		try testing.expectEqual(crc_16_profibus.check, Crc16Profibus.hash("123456789"));
938
939		var c = Crc16Profibus.init();
940		c.update("1234");
941		c.update("56789");
942		try testing.expectEqual(crc_16_profibus.check, c.final());
943		}
944
945		const crc_16_riello: Algorithm(u16) = .{ .poly = 0x1021, .init = 0xb2aa, .refin = true, .refout = true, .xorout = 0x0000, .check = 0x63d0, .residue = 0x0000 };
946
947		pub const Crc16Riello = Crc(u16, crc_16_riello);
948
949		test "CRC-16/RIELLO" {
950		try testing.expectEqual(crc_16_riello.check, Crc16Riello.hash("123456789"));
951
952		var c = Crc16Riello.init();
953		c.update("1234");
954		c.update("56789");
955		try testing.expectEqual(crc_16_riello.check, c.final());
956		}
957
958		const crc_16_spi_fujitsu: Algorithm(u16) = .{ .poly = 0x1021, .init = 0x1d0f, .refin = false, .refout = false, .xorout = 0x0000, .check = 0xe5cc, .residue = 0x0000 };
959
960		pub const Crc16SpiFujitsu = Crc(u16, crc_16_spi_fujitsu);
961
962		test "CRC-16/SPI-FUJITSU" {
963		try testing.expectEqual(crc_16_spi_fujitsu.check, Crc16SpiFujitsu.hash("123456789"));
964
965		var c = Crc16SpiFujitsu.init();
966		c.update("1234");
967		c.update("56789");
968		try testing.expectEqual(crc_16_spi_fujitsu.check, c.final());
969		}
970
971		const crc_16_t10_dif: Algorithm(u16) = .{ .poly = 0x8bb7, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0xd0db, .residue = 0x0000 };
972
973		pub const Crc16T10Dif = Crc(u16, crc_16_t10_dif);
974
975		test "CRC-16/T10-DIF" {
976		try testing.expectEqual(crc_16_t10_dif.check, Crc16T10Dif.hash("123456789"));
977
978		var c = Crc16T10Dif.init();
979		c.update("1234");
980		c.update("56789");
981		try testing.expectEqual(crc_16_t10_dif.check, c.final());
982		}
983
984		const crc_16_teledisk: Algorithm(u16) = .{ .poly = 0xa097, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x0fb3, .residue = 0x0000 };
985
986		pub const Crc16Teledisk = Crc(u16, crc_16_teledisk);
987
988		test "CRC-16/TELEDISK" {
989		try testing.expectEqual(crc_16_teledisk.check, Crc16Teledisk.hash("123456789"));
990
991		var c = Crc16Teledisk.init();
992		c.update("1234");
993		c.update("56789");
994		try testing.expectEqual(crc_16_teledisk.check, c.final());
995		}
996
997		const crc_16_tms37157: Algorithm(u16) = .{ .poly = 0x1021, .init = 0x89ec, .refin = true, .refout = true, .xorout = 0x0000, .check = 0x26b1, .residue = 0x0000 };
998
999		pub const Crc16Tms37157 = Crc(u16, crc_16_tms37157);
1000
1001		test "CRC-16/TMS37157" {
1002		try testing.expectEqual(crc_16_tms37157.check, Crc16Tms37157.hash("123456789"));
1003
1004		var c = Crc16Tms37157.init();
1005		c.update("1234");
1006		c.update("56789");
1007		try testing.expectEqual(crc_16_tms37157.check, c.final());
1008		}
1009
1010		const crc_16_umts: Algorithm(u16) = .{ .poly = 0x8005, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0xfee8, .residue = 0x0000 };
1011
1012		pub const Crc16Umts = Crc(u16, crc_16_umts);
1013
1014		test "CRC-16/UMTS" {
1015		try testing.expectEqual(crc_16_umts.check, Crc16Umts.hash("123456789"));
1016
1017		var c = Crc16Umts.init();
1018		c.update("1234");
1019		c.update("56789");
1020		try testing.expectEqual(crc_16_umts.check, c.final());
1021		}
1022
1023		const crc_16_usb: Algorithm(u16) = .{ .poly = 0x8005, .init = 0xffff, .refin = true, .refout = true, .xorout = 0xffff, .check = 0xb4c8, .residue = 0xb001 };
1024
1025		pub const Crc16Usb = Crc(u16, crc_16_usb);
1026
1027		test "CRC-16/USB" {
1028		try testing.expectEqual(crc_16_usb.check, Crc16Usb.hash("123456789"));
1029
1030		var c = Crc16Usb.init();
1031		c.update("1234");
1032		c.update("56789");
1033		try testing.expectEqual(crc_16_usb.check, c.final());
1034		}
1035
1036		const crc_16_xmodem: Algorithm(u16) = .{ .poly = 0x1021, .init = 0x0000, .refin = false, .refout = false, .xorout = 0x0000, .check = 0x31c3, .residue = 0x0000 };
1037
1038		pub const Crc16Xmodem = Crc(u16, crc_16_xmodem);
1039
1040		test "CRC-16/XMODEM" {
1041		try testing.expectEqual(crc_16_xmodem.check, Crc16Xmodem.hash("123456789"));
1042
1043		var c = Crc16Xmodem.init();
1044		c.update("1234");
1045		c.update("56789");
1046		try testing.expectEqual(crc_16_xmodem.check, c.final());
1047		}
1048
1049		const crc_17_can_fd: Algorithm(u17) = .{ .poly = 0x1685b, .init = 0x00000, .refin = false, .refout = false, .xorout = 0x00000, .check = 0x04f03, .residue = 0x00000 };
1050
1051		pub const Crc17CanFd = Crc(u17, crc_17_can_fd);
1052
1053		test "CRC-17/CAN-FD" {
1054		try testing.expectEqual(crc_17_can_fd.check, Crc17CanFd.hash("123456789"));
1055
1056		var c = Crc17CanFd.init();
1057		c.update("1234");
1058		c.update("56789");
1059		try testing.expectEqual(crc_17_can_fd.check, c.final());
1060		}
1061
1062		const crc_21_can_fd: Algorithm(u21) = .{ .poly = 0x102899, .init = 0x000000, .refin = false, .refout = false, .xorout = 0x000000, .check = 0x0ed841, .residue = 0x000000 };
1063
1064		pub const Crc21CanFd = Crc(u21, crc_21_can_fd);
1065
1066		test "CRC-21/CAN-FD" {
1067		try testing.expectEqual(crc_21_can_fd.check, Crc21CanFd.hash("123456789"));
1068
1069		var c = Crc21CanFd.init();
1070		c.update("1234");
1071		c.update("56789");
1072		try testing.expectEqual(crc_21_can_fd.check, c.final());
1073		}
1074
1075		const crc_24_ble: Algorithm(u24) = .{ .poly = 0x00065b, .init = 0x555555, .refin = true, .refout = true, .xorout = 0x000000, .check = 0xc25a56, .residue = 0x000000 };
1076
1077		pub const Crc24Ble = Crc(u24, crc_24_ble);
1078
1079		test "CRC-24/BLE" {
1080		try testing.expectEqual(crc_24_ble.check, Crc24Ble.hash("123456789"));
1081
1082		var c = Crc24Ble.init();
1083		c.update("1234");
1084		c.update("56789");
1085		try testing.expectEqual(crc_24_ble.check, c.final());
1086		}
1087
1088		const crc_24_flexray_a: Algorithm(u24) = .{ .poly = 0x5d6dcb, .init = 0xfedcba, .refin = false, .refout = false, .xorout = 0x000000, .check = 0x7979bd, .residue = 0x000000 };
1089
1090		pub const Crc24FlexrayA = Crc(u24, crc_24_flexray_a);
1091
1092		test "CRC-24/FLEXRAY-A" {
1093		try testing.expectEqual(crc_24_flexray_a.check, Crc24FlexrayA.hash("123456789"));
1094
1095		var c = Crc24FlexrayA.init();
1096		c.update("1234");
1097		c.update("56789");
1098		try testing.expectEqual(crc_24_flexray_a.check, c.final());
1099		}
1100
1101		const crc_24_flexray_b: Algorithm(u24) = .{ .poly = 0x5d6dcb, .init = 0xabcdef, .refin = false, .refout = false, .xorout = 0x000000, .check = 0x1f23b8, .residue = 0x000000 };
1102
1103		pub const Crc24FlexrayB = Crc(u24, crc_24_flexray_b);
1104
1105		test "CRC-24/FLEXRAY-B" {
1106		try testing.expectEqual(crc_24_flexray_b.check, Crc24FlexrayB.hash("123456789"));
1107
1108		var c = Crc24FlexrayB.init();
1109		c.update("1234");
1110		c.update("56789");
1111		try testing.expectEqual(crc_24_flexray_b.check, c.final());
1112		}
1113
1114		const crc_24_interlaken: Algorithm(u24) = .{ .poly = 0x328b63, .init = 0xffffff, .refin = false, .refout = false, .xorout = 0xffffff, .check = 0xb4f3e6, .residue = 0x144e63 };
1115
1116		pub const Crc24Interlaken = Crc(u24, crc_24_interlaken);
1117
1118		test "CRC-24/INTERLAKEN" {
1119		try testing.expectEqual(crc_24_interlaken.check, Crc24Interlaken.hash("123456789"));
1120
1121		var c = Crc24Interlaken.init();
1122		c.update("1234");
1123		c.update("56789");
1124		try testing.expectEqual(crc_24_interlaken.check, c.final());
1125		}
1126
1127		const crc_24_lte_a: Algorithm(u24) = .{ .poly = 0x864cfb, .init = 0x000000, .refin = false, .refout = false, .xorout = 0x000000, .check = 0xcde703, .residue = 0x000000 };
1128
1129		pub const Crc24LteA = Crc(u24, crc_24_lte_a);
1130
1131		test "CRC-24/LTE-A" {
1132		try testing.expectEqual(crc_24_lte_a.check, Crc24LteA.hash("123456789"));
1133
1134		var c = Crc24LteA.init();
1135		c.update("1234");
1136		c.update("56789");
1137		try testing.expectEqual(crc_24_lte_a.check, c.final());
1138		}
1139
1140		const crc_24_lte_b: Algorithm(u24) = .{ .poly = 0x800063, .init = 0x000000, .refin = false, .refout = false, .xorout = 0x000000, .check = 0x23ef52, .residue = 0x000000 };
1141
1142		pub const Crc24LteB = Crc(u24, crc_24_lte_b);
1143
1144		test "CRC-24/LTE-B" {
1145		try testing.expectEqual(crc_24_lte_b.check, Crc24LteB.hash("123456789"));
1146
1147		var c = Crc24LteB.init();
1148		c.update("1234");
1149		c.update("56789");
1150		try testing.expectEqual(crc_24_lte_b.check, c.final());
1151		}
1152
1153		const crc_24_openpgp: Algorithm(u24) = .{ .poly = 0x864cfb, .init = 0xb704ce, .refin = false, .refout = false, .xorout = 0x000000, .check = 0x21cf02, .residue = 0x000000 };
1154
1155		pub const Crc24Openpgp = Crc(u24, crc_24_openpgp);
1156
1157		test "CRC-24/OPENPGP" {
1158		try testing.expectEqual(crc_24_openpgp.check, Crc24Openpgp.hash("123456789"));
1159
1160		var c = Crc24Openpgp.init();
1161		c.update("1234");
1162		c.update("56789");
1163		try testing.expectEqual(crc_24_openpgp.check, c.final());
1164		}
1165
1166		const crc_24_os_9: Algorithm(u24) = .{ .poly = 0x800063, .init = 0xffffff, .refin = false, .refout = false, .xorout = 0xffffff, .check = 0x200fa5, .residue = 0x800fe3 };
1167
1168		pub const Crc24Os9 = Crc(u24, crc_24_os_9);
1169
1170		test "CRC-24/OS-9" {
1171		try testing.expectEqual(crc_24_os_9.check, Crc24Os9.hash("123456789"));
1172
1173		var c = Crc24Os9.init();
1174		c.update("1234");
1175		c.update("56789");
1176		try testing.expectEqual(crc_24_os_9.check, c.final());
1177		}
1178
1179		const crc_30_cdma: Algorithm(u30) = .{ .poly = 0x2030b9c7, .init = 0x3fffffff, .refin = false, .refout = false, .xorout = 0x3fffffff, .check = 0x04c34abf, .residue = 0x34efa55a };
1180
1181		pub const Crc30Cdma = Crc(u30, crc_30_cdma);
1182
1183		test "CRC-30/CDMA" {
1184		try testing.expectEqual(crc_30_cdma.check, Crc30Cdma.hash("123456789"));
1185
1186		var c = Crc30Cdma.init();
1187		c.update("1234");
1188		c.update("56789");
1189		try testing.expectEqual(crc_30_cdma.check, c.final());
1190		}
1191
1192		const crc_31_philips: Algorithm(u31) = .{ .poly = 0x04c11db7, .init = 0x7fffffff, .refin = false, .refout = false, .xorout = 0x7fffffff, .check = 0x0ce9e46c, .residue = 0x4eaf26f1 };
1193
1194		pub const Crc31Philips = Crc(u31, crc_31_philips);
1195
1196		test "CRC-31/PHILIPS" {
1197		try testing.expectEqual(crc_31_philips.check, Crc31Philips.hash("123456789"));
1198
1199		var c = Crc31Philips.init();
1200		c.update("1234");
1201		c.update("56789");
1202		try testing.expectEqual(crc_31_philips.check, c.final());
1203		}
1204
1205		const crc_32_aixm: Algorithm(u32) = .{ .poly = 0x814141ab, .init = 0x00000000, .refin = false, .refout = false, .xorout = 0x00000000, .check = 0x3010bf7f, .residue = 0x00000000 };
1206
1207		pub const Crc32Aixm = Crc(u32, crc_32_aixm);
1208
1209		test "CRC-32/AIXM" {
1210		try testing.expectEqual(crc_32_aixm.check, Crc32Aixm.hash("123456789"));
1211
1212		var c = Crc32Aixm.init();
1213		c.update("1234");
1214		c.update("56789");
1215		try testing.expectEqual(crc_32_aixm.check, c.final());
1216		}
1217
1218		const crc_32_autosar: Algorithm(u32) = .{ .poly = 0xf4acfb13, .init = 0xffffffff, .refin = true, .refout = true, .xorout = 0xffffffff, .check = 0x1697d06a, .residue = 0x904cddbf };
1219
1220		pub const Crc32Autosar = Crc(u32, crc_32_autosar);
1221
1222		test "CRC-32/AUTOSAR" {
1223		try testing.expectEqual(crc_32_autosar.check, Crc32Autosar.hash("123456789"));
1224
1225		var c = Crc32Autosar.init();
1226		c.update("1234");
1227		c.update("56789");
1228		try testing.expectEqual(crc_32_autosar.check, c.final());
1229		}
1230
1231		const crc_32_base91_d: Algorithm(u32) = .{ .poly = 0xa833982b, .init = 0xffffffff, .refin = true, .refout = true, .xorout = 0xffffffff, .check = 0x87315576, .residue = 0x45270551 };
1232
1233		pub const Crc32Base91D = Crc(u32, crc_32_base91_d);
1234
1235		test "CRC-32/BASE91-D" {
1236		try testing.expectEqual(crc_32_base91_d.check, Crc32Base91D.hash("123456789"));
1237
1238		var c = Crc32Base91D.init();
1239		c.update("1234");
1240		c.update("56789");
1241		try testing.expectEqual(crc_32_base91_d.check, c.final());
1242		}
1243
1244		const crc_32_bzip2: Algorithm(u32) = .{ .poly = 0x04c11db7, .init = 0xffffffff, .refin = false, .refout = false, .xorout = 0xffffffff, .check = 0xfc891918, .residue = 0xc704dd7b };
1245
1246		pub const Crc32Bzip2 = Crc(u32, crc_32_bzip2);
1247
1248		test "CRC-32/BZIP2" {
1249		try testing.expectEqual(crc_32_bzip2.check, Crc32Bzip2.hash("123456789"));
1250
1251		var c = Crc32Bzip2.init();
1252		c.update("1234");
1253		c.update("56789");
1254		try testing.expectEqual(crc_32_bzip2.check, c.final());
1255		}
1256
1257		const crc_32_cd_rom_edc: Algorithm(u32) = .{ .poly = 0x8001801b, .init = 0x00000000, .refin = true, .refout = true, .xorout = 0x00000000, .check = 0x6ec2edc4, .residue = 0x00000000 };
1258
1259		pub const Crc32CdRomEdc = Crc(u32, crc_32_cd_rom_edc);
1260
1261		test "CRC-32/CD-ROM-EDC" {
1262		try testing.expectEqual(crc_32_cd_rom_edc.check, Crc32CdRomEdc.hash("123456789"));
1263
1264		var c = Crc32CdRomEdc.init();
1265		c.update("1234");
1266		c.update("56789");
1267		try testing.expectEqual(crc_32_cd_rom_edc.check, c.final());
1268		}
1269
1270		const crc_32_cksum: Algorithm(u32) = .{ .poly = 0x04c11db7, .init = 0x00000000, .refin = false, .refout = false, .xorout = 0xffffffff, .check = 0x765e7680, .residue = 0xc704dd7b };
1271
1272		pub const Crc32Cksum = Crc(u32, crc_32_cksum);
1273
1274		test "CRC-32/CKSUM" {
1275		try testing.expectEqual(crc_32_cksum.check, Crc32Cksum.hash("123456789"));
1276
1277		var c = Crc32Cksum.init();
1278		c.update("1234");
1279		c.update("56789");
1280		try testing.expectEqual(crc_32_cksum.check, c.final());
1281		}
1282
1283		const crc_32_iscsi: Algorithm(u32) = .{ .poly = 0x1edc6f41, .init = 0xffffffff, .refin = true, .refout = true, .xorout = 0xffffffff, .check = 0xe3069283, .residue = 0xb798b438 };
1284
1285		pub const Crc32Iscsi = Crc(u32, crc_32_iscsi);
1286
1287		test "CRC-32/ISCSI" {
1288		try testing.expectEqual(crc_32_iscsi.check, Crc32Iscsi.hash("123456789"));
1289
1290		var c = Crc32Iscsi.init();
1291		c.update("1234");
1292		c.update("56789");
1293		try testing.expectEqual(crc_32_iscsi.check, c.final());
1294		}
1295
1296		const crc_32_iso_hdlc: Algorithm(u32) = .{ .poly = 0x04c11db7, .init = 0xffffffff, .refin = true, .refout = true, .xorout = 0xffffffff, .check = 0xcbf43926, .residue = 0xdebb20e3 };
1297
1298		pub const Crc32IsoHdlc = Crc(u32, crc_32_iso_hdlc);
1299
1300		test "CRC-32/ISO-HDLC" {
1301		try testing.expectEqual(crc_32_iso_hdlc.check, Crc32IsoHdlc.hash("123456789"));
1302
1303		var c = Crc32IsoHdlc.init();
1304		c.update("1234");
1305		c.update("56789");
1306		try testing.expectEqual(crc_32_iso_hdlc.check, c.final());
1307		}
1308
1309		const crc_32_jamcrc: Algorithm(u32) = .{ .poly = 0x04c11db7, .init = 0xffffffff, .refin = true, .refout = true, .xorout = 0x00000000, .check = 0x340bc6d9, .residue = 0x00000000 };
1310
1311		pub const Crc32Jamcrc = Crc(u32, crc_32_jamcrc);
1312
1313		test "CRC-32/JAMCRC" {
1314		try testing.expectEqual(crc_32_jamcrc.check, Crc32Jamcrc.hash("123456789"));
1315
1316		var c = Crc32Jamcrc.init();
1317		c.update("1234");
1318		c.update("56789");
1319		try testing.expectEqual(crc_32_jamcrc.check, c.final());
1320		}
1321
1322		const crc_32_mef: Algorithm(u32) = .{ .poly = 0x741b8cd7, .init = 0xffffffff, .refin = true, .refout = true, .xorout = 0x00000000, .check = 0xd2c22f51, .residue = 0x00000000 };
1323
1324		pub const Crc32Mef = Crc(u32, crc_32_mef);
1325
1326		test "CRC-32/MEF" {
1327		try testing.expectEqual(crc_32_mef.check, Crc32Mef.hash("123456789"));
1328
1329		var c = Crc32Mef.init();
1330		c.update("1234");
1331		c.update("56789");
1332		try testing.expectEqual(crc_32_mef.check, c.final());
1333		}
1334
1335		const crc_32_mpeg_2: Algorithm(u32) = .{ .poly = 0x04c11db7, .init = 0xffffffff, .refin = false, .refout = false, .xorout = 0x00000000, .check = 0x0376e6e7, .residue = 0x00000000 };
1336
1337		pub const Crc32Mpeg2 = Crc(u32, crc_32_mpeg_2);
1338
1339		test "CRC-32/MPEG-2" {
1340		try testing.expectEqual(crc_32_mpeg_2.check, Crc32Mpeg2.hash("123456789"));
1341
1342		var c = Crc32Mpeg2.init();
1343		c.update("1234");
1344		c.update("56789");
1345		try testing.expectEqual(crc_32_mpeg_2.check, c.final());
1346		}
1347
1348		const crc_32_xfer: Algorithm(u32) = .{ .poly = 0x000000af, .init = 0x00000000, .refin = false, .refout = false, .xorout = 0x00000000, .check = 0xbd0be338, .residue = 0x00000000 };
1349
1350		pub const Crc32Xfer = Crc(u32, crc_32_xfer);
1351
1352		test "CRC-32/XFER" {
1353		try testing.expectEqual(crc_32_xfer.check, Crc32Xfer.hash("123456789"));
1354
1355		var c = Crc32Xfer.init();
1356		c.update("1234");
1357		c.update("56789");
1358		try testing.expectEqual(crc_32_xfer.check, c.final());
1359		}
1360
1361		const crc_40_gsm: Algorithm(u40) = .{ .poly = 0x0004820009, .init = 0x0000000000, .refin = false, .refout = false, .xorout = 0xffffffffff, .check = 0xd4164fc646, .residue = 0xc4ff8071ff };
1362
1363		pub const Crc40Gsm = Crc(u40, crc_40_gsm);
1364
1365		test "CRC-40/GSM" {
1366		try testing.expectEqual(crc_40_gsm.check, Crc40Gsm.hash("123456789"));
1367
1368		var c = Crc40Gsm.init();
1369		c.update("1234");
1370		c.update("56789");
1371		try testing.expectEqual(crc_40_gsm.check, c.final());
1372		}
1373
1374		const crc_64_ecma_182: Algorithm(u64) = .{ .poly = 0x42f0e1eba9ea3693, .init = 0x0000000000000000, .refin = false, .refout = false, .xorout = 0x0000000000000000, .check = 0x6c40df5f0b497347, .residue = 0x0000000000000000 };
1375
1376		pub const Crc64Ecma182 = Crc(u64, crc_64_ecma_182);
1377
1378		test "CRC-64/ECMA-182" {
1379		try testing.expectEqual(crc_64_ecma_182.check, Crc64Ecma182.hash("123456789"));
1380
1381		var c = Crc64Ecma182.init();
1382		c.update("1234");
1383		c.update("56789");
1384		try testing.expectEqual(crc_64_ecma_182.check, c.final());
1385		}
1386
1387		const crc_64_go_iso: Algorithm(u64) = .{ .poly = 0x000000000000001b, .init = 0xffffffffffffffff, .refin = true, .refout = true, .xorout = 0xffffffffffffffff, .check = 0xb90956c775a41001, .residue = 0x5300000000000000 };
1388
1389		pub const Crc64GoIso = Crc(u64, crc_64_go_iso);
1390
1391		test "CRC-64/GO-ISO" {
1392		try testing.expectEqual(crc_64_go_iso.check, Crc64GoIso.hash("123456789"));
1393
1394		var c = Crc64GoIso.init();
1395		c.update("1234");
1396		c.update("56789");
1397		try testing.expectEqual(crc_64_go_iso.check, c.final());
1398		}
1399
1400		const crc_64_ms: Algorithm(u64) = .{ .poly = 0x259c84cba6426349, .init = 0xffffffffffffffff, .refin = true, .refout = true, .xorout = 0x0000000000000000, .check = 0x75d4b74f024eceea, .residue = 0x0000000000000000 };
1401
1402		pub const Crc64Ms = Crc(u64, crc_64_ms);
1403
1404		test "CRC-64/MS" {
1405		try testing.expectEqual(crc_64_ms.check, Crc64Ms.hash("123456789"));
1406
1407		var c = Crc64Ms.init();
1408		c.update("1234");
1409		c.update("56789");
1410		try testing.expectEqual(crc_64_ms.check, c.final());
1411		}
1412
1413		const crc_64_redis: Algorithm(u64) = .{ .poly = 0xad93d23594c935a9, .init = 0x0000000000000000, .refin = true, .refout = true, .xorout = 0x0000000000000000, .check = 0xe9c6d914c4b8d9ca, .residue = 0x0000000000000000 };
1414
1415		pub const Crc64Redis = Crc(u64, crc_64_redis);
1416
1417		test "CRC-64/REDIS" {
1418		try testing.expectEqual(crc_64_redis.check, Crc64Redis.hash("123456789"));
1419
1420		var c = Crc64Redis.init();
1421		c.update("1234");
1422		c.update("56789");
1423		try testing.expectEqual(crc_64_redis.check, c.final());
1424		}
1425
1426		const crc_64_we: Algorithm(u64) = .{ .poly = 0x42f0e1eba9ea3693, .init = 0xffffffffffffffff, .refin = false, .refout = false, .xorout = 0xffffffffffffffff, .check = 0x62ec59e3f1a4f00a, .residue = 0xfcacbebd5931a992 };
1427
1428		pub const Crc64We = Crc(u64, crc_64_we);
1429
1430		test "CRC-64/WE" {
1431		try testing.expectEqual(crc_64_we.check, Crc64We.hash("123456789"));
1432
1433		var c = Crc64We.init();
1434		c.update("1234");
1435		c.update("56789");
1436		try testing.expectEqual(crc_64_we.check, c.final());
1437		}
1438
1439		const crc_64_xz: Algorithm(u64) = .{ .poly = 0x42f0e1eba9ea3693, .init = 0xffffffffffffffff, .refin = true, .refout = true, .xorout = 0xffffffffffffffff, .check = 0x995dc9bbdf1939fa, .residue = 0x49958c9abd7d353f };
1440
1441		pub const Crc64Xz = Crc(u64, crc_64_xz);
1442
1443		test "CRC-64/XZ" {
1444		try testing.expectEqual(crc_64_xz.check, Crc64Xz.hash("123456789"));
1445
1446		var c = Crc64Xz.init();
1447		c.update("1234");
1448		c.update("56789");
1449		try testing.expectEqual(crc_64_xz.check, c.final());
1450		}
1451
1452		const crc_82_darc: Algorithm(u82) = .{ .poly = 0x0308c0111011401440411, .init = 0x000000000000000000000, .refin = true, .refout = true, .xorout = 0x000000000000000000000, .check = 0x09ea83f625023801fd612, .residue = 0x000000000000000000000 };
1453
1454		pub const Crc82Darc = Crc(u82, crc_82_darc);
1455
1456		test "CRC-82/DARC" {
1457		try testing.expectEqual(crc_82_darc.check, Crc82Darc.hash("123456789"));
1458
1459		var c = Crc82Darc.init();
1460		c.update("1234");
1461		c.update("56789");
1462		try testing.expectEqual(crc_82_darc.check, c.final());
1463		}
	1	//! This file is auto-generated by tools/update_crc_catalog.zig.
	2
	3	const Crc = @import("../crc.zig").Crc;
	4
	5	test {
	6	_ = @import("catalog_test.zig");
	7	}
	8
	9	pub const Crc3Gsm = Crc(u3, .{
	10	.polynomial = 0x3,
	11	.initial = 0x0,
	12	.reflect_input = false,
	13	.reflect_output = false,
	14	.xor_output = 0x7,
	15	});
	16
	17	pub const Crc3Rohc = Crc(u3, .{
	18	.polynomial = 0x3,
	19	.initial = 0x7,
	20	.reflect_input = true,
	21	.reflect_output = true,
	22	.xor_output = 0x0,
	23	});
	24
	25	pub const Crc4G704 = Crc(u4, .{
	26	.polynomial = 0x3,
	27	.initial = 0x0,
	28	.reflect_input = true,
	29	.reflect_output = true,
	30	.xor_output = 0x0,
	31	});
	32
	33	pub const Crc4Interlaken = Crc(u4, .{
	34	.polynomial = 0x3,
	35	.initial = 0xf,
	36	.reflect_input = false,
	37	.reflect_output = false,
	38	.xor_output = 0xf,
	39	});
	40
	41	pub const Crc5EpcC1g2 = Crc(u5, .{
	42	.polynomial = 0x09,
	43	.initial = 0x09,
	44	.reflect_input = false,
	45	.reflect_output = false,
	46	.xor_output = 0x00,
	47	});
	48
	49	pub const Crc5G704 = Crc(u5, .{
	50	.polynomial = 0x15,
	51	.initial = 0x00,
	52	.reflect_input = true,
	53	.reflect_output = true,
	54	.xor_output = 0x00,
	55	});
	56
	57	pub const Crc5Usb = Crc(u5, .{
	58	.polynomial = 0x05,
	59	.initial = 0x1f,
	60	.reflect_input = true,
	61	.reflect_output = true,
	62	.xor_output = 0x1f,
	63	});
	64
	65	pub const Crc6Cdma2000A = Crc(u6, .{
	66	.polynomial = 0x27,
	67	.initial = 0x3f,
	68	.reflect_input = false,
	69	.reflect_output = false,
	70	.xor_output = 0x00,
	71	});
	72
	73	pub const Crc6Cdma2000B = Crc(u6, .{
	74	.polynomial = 0x07,
	75	.initial = 0x3f,
	76	.reflect_input = false,
	77	.reflect_output = false,
	78	.xor_output = 0x00,
	79	});
	80
	81	pub const Crc6Darc = Crc(u6, .{
	82	.polynomial = 0x19,
	83	.initial = 0x00,
	84	.reflect_input = true,
	85	.reflect_output = true,
	86	.xor_output = 0x00,
	87	});
	88
	89	pub const Crc6G704 = Crc(u6, .{
	90	.polynomial = 0x03,
	91	.initial = 0x00,
	92	.reflect_input = true,
	93	.reflect_output = true,
	94	.xor_output = 0x00,
	95	});
	96
	97	pub const Crc6Gsm = Crc(u6, .{
	98	.polynomial = 0x2f,
	99	.initial = 0x00,
	100	.reflect_input = false,
	101	.reflect_output = false,
	102	.xor_output = 0x3f,
	103	});
	104
	105	pub const Crc7Mmc = Crc(u7, .{
	106	.polynomial = 0x09,
	107	.initial = 0x00,
	108	.reflect_input = false,
	109	.reflect_output = false,
	110	.xor_output = 0x00,
	111	});
	112
	113	pub const Crc7Rohc = Crc(u7, .{
	114	.polynomial = 0x4f,
	115	.initial = 0x7f,
	116	.reflect_input = true,
	117	.reflect_output = true,
	118	.xor_output = 0x00,
	119	});
	120
	121	pub const Crc7Umts = Crc(u7, .{
	122	.polynomial = 0x45,
	123	.initial = 0x00,
	124	.reflect_input = false,
	125	.reflect_output = false,
	126	.xor_output = 0x00,
	127	});
	128
	129	pub const Crc8Autosar = Crc(u8, .{
	130	.polynomial = 0x2f,
	131	.initial = 0xff,
	132	.reflect_input = false,
	133	.reflect_output = false,
	134	.xor_output = 0xff,
	135	});
	136
	137	pub const Crc8Bluetooth = Crc(u8, .{
	138	.polynomial = 0xa7,
	139	.initial = 0x00,
	140	.reflect_input = true,
	141	.reflect_output = true,
	142	.xor_output = 0x00,
	143	});
	144
	145	pub const Crc8Cdma2000 = Crc(u8, .{
	146	.polynomial = 0x9b,
	147	.initial = 0xff,
	148	.reflect_input = false,
	149	.reflect_output = false,
	150	.xor_output = 0x00,
	151	});
	152
	153	pub const Crc8Darc = Crc(u8, .{
	154	.polynomial = 0x39,
	155	.initial = 0x00,
	156	.reflect_input = true,
	157	.reflect_output = true,
	158	.xor_output = 0x00,
	159	});
	160
	161	pub const Crc8DvbS2 = Crc(u8, .{
	162	.polynomial = 0xd5,
	163	.initial = 0x00,
	164	.reflect_input = false,
	165	.reflect_output = false,
	166	.xor_output = 0x00,
	167	});
	168
	169	pub const Crc8GsmA = Crc(u8, .{
	170	.polynomial = 0x1d,
	171	.initial = 0x00,
	172	.reflect_input = false,
	173	.reflect_output = false,
	174	.xor_output = 0x00,
	175	});
	176
	177	pub const Crc8GsmB = Crc(u8, .{
	178	.polynomial = 0x49,
	179	.initial = 0x00,
	180	.reflect_input = false,
	181	.reflect_output = false,
	182	.xor_output = 0xff,
	183	});
	184
	185	pub const Crc8Hitag = Crc(u8, .{
	186	.polynomial = 0x1d,
	187	.initial = 0xff,
	188	.reflect_input = false,
	189	.reflect_output = false,
	190	.xor_output = 0x00,
	191	});
	192
	193	pub const Crc8I4321 = Crc(u8, .{
	194	.polynomial = 0x07,
	195	.initial = 0x00,
	196	.reflect_input = false,
	197	.reflect_output = false,
	198	.xor_output = 0x55,
	199	});
	200
	201	pub const Crc8ICode = Crc(u8, .{
	202	.polynomial = 0x1d,
	203	.initial = 0xfd,
	204	.reflect_input = false,
	205	.reflect_output = false,
	206	.xor_output = 0x00,
	207	});
	208
	209	pub const Crc8Lte = Crc(u8, .{
	210	.polynomial = 0x9b,
	211	.initial = 0x00,
	212	.reflect_input = false,
	213	.reflect_output = false,
	214	.xor_output = 0x00,
	215	});
	216
	217	pub const Crc8MaximDow = Crc(u8, .{
	218	.polynomial = 0x31,
	219	.initial = 0x00,
	220	.reflect_input = true,
	221	.reflect_output = true,
	222	.xor_output = 0x00,
	223	});
	224
	225	pub const Crc8MifareMad = Crc(u8, .{
	226	.polynomial = 0x1d,
	227	.initial = 0xc7,
	228	.reflect_input = false,
	229	.reflect_output = false,
	230	.xor_output = 0x00,
	231	});
	232
	233	pub const Crc8Nrsc5 = Crc(u8, .{
	234	.polynomial = 0x31,
	235	.initial = 0xff,
	236	.reflect_input = false,
	237	.reflect_output = false,
	238	.xor_output = 0x00,
	239	});
	240
	241	pub const Crc8Opensafety = Crc(u8, .{
	242	.polynomial = 0x2f,
	243	.initial = 0x00,
	244	.reflect_input = false,
	245	.reflect_output = false,
	246	.xor_output = 0x00,
	247	});
	248
	249	pub const Crc8Rohc = Crc(u8, .{
	250	.polynomial = 0x07,
	251	.initial = 0xff,
	252	.reflect_input = true,
	253	.reflect_output = true,
	254	.xor_output = 0x00,
	255	});
	256
	257	pub const Crc8SaeJ1850 = Crc(u8, .{
	258	.polynomial = 0x1d,
	259	.initial = 0xff,
	260	.reflect_input = false,
	261	.reflect_output = false,
	262	.xor_output = 0xff,
	263	});
	264
	265	pub const Crc8Smbus = Crc(u8, .{
	266	.polynomial = 0x07,
	267	.initial = 0x00,
	268	.reflect_input = false,
	269	.reflect_output = false,
	270	.xor_output = 0x00,
	271	});
	272
	273	pub const Crc8Tech3250 = Crc(u8, .{
	274	.polynomial = 0x1d,
	275	.initial = 0xff,
	276	.reflect_input = true,
	277	.reflect_output = true,
	278	.xor_output = 0x00,
	279	});
	280
	281	pub const Crc8Wcdma = Crc(u8, .{
	282	.polynomial = 0x9b,
	283	.initial = 0x00,
	284	.reflect_input = true,
	285	.reflect_output = true,
	286	.xor_output = 0x00,
	287	});
	288
	289	pub const Crc10Atm = Crc(u10, .{
	290	.polynomial = 0x233,
	291	.initial = 0x000,
	292	.reflect_input = false,
	293	.reflect_output = false,
	294	.xor_output = 0x000,
	295	});
	296
	297	pub const Crc10Cdma2000 = Crc(u10, .{
	298	.polynomial = 0x3d9,
	299	.initial = 0x3ff,
	300	.reflect_input = false,
	301	.reflect_output = false,
	302	.xor_output = 0x000,
	303	});
	304
	305	pub const Crc10Gsm = Crc(u10, .{
	306	.polynomial = 0x175,
	307	.initial = 0x000,
	308	.reflect_input = false,
	309	.reflect_output = false,
	310	.xor_output = 0x3ff,
	311	});
	312
	313	pub const Crc11Flexray = Crc(u11, .{
	314	.polynomial = 0x385,
	315	.initial = 0x01a,
	316	.reflect_input = false,
	317	.reflect_output = false,
	318	.xor_output = 0x000,
	319	});
	320
	321	pub const Crc11Umts = Crc(u11, .{
	322	.polynomial = 0x307,
	323	.initial = 0x000,
	324	.reflect_input = false,
	325	.reflect_output = false,
	326	.xor_output = 0x000,
	327	});
	328
	329	pub const Crc12Cdma2000 = Crc(u12, .{
	330	.polynomial = 0xf13,
	331	.initial = 0xfff,
	332	.reflect_input = false,
	333	.reflect_output = false,
	334	.xor_output = 0x000,
	335	});
	336
	337	pub const Crc12Dect = Crc(u12, .{
	338	.polynomial = 0x80f,
	339	.initial = 0x000,
	340	.reflect_input = false,
	341	.reflect_output = false,
	342	.xor_output = 0x000,
	343	});
	344
	345	pub const Crc12Gsm = Crc(u12, .{
	346	.polynomial = 0xd31,
	347	.initial = 0x000,
	348	.reflect_input = false,
	349	.reflect_output = false,
	350	.xor_output = 0xfff,
	351	});
	352
	353	pub const Crc12Umts = Crc(u12, .{
	354	.polynomial = 0x80f,
	355	.initial = 0x000,
	356	.reflect_input = false,
	357	.reflect_output = true,
	358	.xor_output = 0x000,
	359	});
	360
	361	pub const Crc13Bbc = Crc(u13, .{
	362	.polynomial = 0x1cf5,
	363	.initial = 0x0000,
	364	.reflect_input = false,
	365	.reflect_output = false,
	366	.xor_output = 0x0000,
	367	});
	368
	369	pub const Crc14Darc = Crc(u14, .{
	370	.polynomial = 0x0805,
	371	.initial = 0x0000,
	372	.reflect_input = true,
	373	.reflect_output = true,
	374	.xor_output = 0x0000,
	375	});
	376
	377	pub const Crc14Gsm = Crc(u14, .{
	378	.polynomial = 0x202d,
	379	.initial = 0x0000,
	380	.reflect_input = false,
	381	.reflect_output = false,
	382	.xor_output = 0x3fff,
	383	});
	384
	385	pub const Crc15Can = Crc(u15, .{
	386	.polynomial = 0x4599,
	387	.initial = 0x0000,
	388	.reflect_input = false,
	389	.reflect_output = false,
	390	.xor_output = 0x0000,
	391	});
	392
	393	pub const Crc15Mpt1327 = Crc(u15, .{
	394	.polynomial = 0x6815,
	395	.initial = 0x0000,
	396	.reflect_input = false,
	397	.reflect_output = false,
	398	.xor_output = 0x0001,
	399	});
	400
	401	pub const Crc16Arc = Crc(u16, .{
	402	.polynomial = 0x8005,
	403	.initial = 0x0000,
	404	.reflect_input = true,
	405	.reflect_output = true,
	406	.xor_output = 0x0000,
	407	});
	408
	409	pub const Crc16Cdma2000 = Crc(u16, .{
	410	.polynomial = 0xc867,
	411	.initial = 0xffff,
	412	.reflect_input = false,
	413	.reflect_output = false,
	414	.xor_output = 0x0000,
	415	});
	416
	417	pub const Crc16Cms = Crc(u16, .{
	418	.polynomial = 0x8005,
	419	.initial = 0xffff,
	420	.reflect_input = false,
	421	.reflect_output = false,
	422	.xor_output = 0x0000,
	423	});
	424
	425	pub const Crc16Dds110 = Crc(u16, .{
	426	.polynomial = 0x8005,
	427	.initial = 0x800d,
	428	.reflect_input = false,
	429	.reflect_output = false,
	430	.xor_output = 0x0000,
	431	});
	432
	433	pub const Crc16DectR = Crc(u16, .{
	434	.polynomial = 0x0589,
	435	.initial = 0x0000,
	436	.reflect_input = false,
	437	.reflect_output = false,
	438	.xor_output = 0x0001,
	439	});
	440
	441	pub const Crc16DectX = Crc(u16, .{
	442	.polynomial = 0x0589,
	443	.initial = 0x0000,
	444	.reflect_input = false,
	445	.reflect_output = false,
	446	.xor_output = 0x0000,
	447	});
	448
	449	pub const Crc16Dnp = Crc(u16, .{
	450	.polynomial = 0x3d65,
	451	.initial = 0x0000,
	452	.reflect_input = true,
	453	.reflect_output = true,
	454	.xor_output = 0xffff,
	455	});
	456
	457	pub const Crc16En13757 = Crc(u16, .{
	458	.polynomial = 0x3d65,
	459	.initial = 0x0000,
	460	.reflect_input = false,
	461	.reflect_output = false,
	462	.xor_output = 0xffff,
	463	});
	464
	465	pub const Crc16Genibus = Crc(u16, .{
	466	.polynomial = 0x1021,
	467	.initial = 0xffff,
	468	.reflect_input = false,
	469	.reflect_output = false,
	470	.xor_output = 0xffff,
	471	});
	472
	473	pub const Crc16Gsm = Crc(u16, .{
	474	.polynomial = 0x1021,
	475	.initial = 0x0000,
	476	.reflect_input = false,
	477	.reflect_output = false,
	478	.xor_output = 0xffff,
	479	});
	480
	481	pub const Crc16Ibm3740 = Crc(u16, .{
	482	.polynomial = 0x1021,
	483	.initial = 0xffff,
	484	.reflect_input = false,
	485	.reflect_output = false,
	486	.xor_output = 0x0000,
	487	});
	488
	489	pub const Crc16IbmSdlc = Crc(u16, .{
	490	.polynomial = 0x1021,
	491	.initial = 0xffff,
	492	.reflect_input = true,
	493	.reflect_output = true,
	494	.xor_output = 0xffff,
	495	});
	496
	497	pub const Crc16IsoIec144433A = Crc(u16, .{
	498	.polynomial = 0x1021,
	499	.initial = 0xc6c6,
	500	.reflect_input = true,
	501	.reflect_output = true,
	502	.xor_output = 0x0000,
	503	});
	504
	505	pub const Crc16Kermit = Crc(u16, .{
	506	.polynomial = 0x1021,
	507	.initial = 0x0000,
	508	.reflect_input = true,
	509	.reflect_output = true,
	510	.xor_output = 0x0000,
	511	});
	512
	513	pub const Crc16Lj1200 = Crc(u16, .{
	514	.polynomial = 0x6f63,
	515	.initial = 0x0000,
	516	.reflect_input = false,
	517	.reflect_output = false,
	518	.xor_output = 0x0000,
	519	});
	520
	521	pub const Crc16M17 = Crc(u16, .{
	522	.polynomial = 0x5935,
	523	.initial = 0xffff,
	524	.reflect_input = false,
	525	.reflect_output = false,
	526	.xor_output = 0x0000,
	527	});
	528
	529	pub const Crc16MaximDow = Crc(u16, .{
	530	.polynomial = 0x8005,
	531	.initial = 0x0000,
	532	.reflect_input = true,
	533	.reflect_output = true,
	534	.xor_output = 0xffff,
	535	});
	536
	537	pub const Crc16Mcrf4xx = Crc(u16, .{
	538	.polynomial = 0x1021,
	539	.initial = 0xffff,
	540	.reflect_input = true,
	541	.reflect_output = true,
	542	.xor_output = 0x0000,
	543	});
	544
	545	pub const Crc16Modbus = Crc(u16, .{
	546	.polynomial = 0x8005,
	547	.initial = 0xffff,
	548	.reflect_input = true,
	549	.reflect_output = true,
	550	.xor_output = 0x0000,
	551	});
	552
	553	pub const Crc16Nrsc5 = Crc(u16, .{
	554	.polynomial = 0x080b,
	555	.initial = 0xffff,
	556	.reflect_input = true,
	557	.reflect_output = true,
	558	.xor_output = 0x0000,
	559	});
	560
	561	pub const Crc16OpensafetyA = Crc(u16, .{
	562	.polynomial = 0x5935,
	563	.initial = 0x0000,
	564	.reflect_input = false,
	565	.reflect_output = false,
	566	.xor_output = 0x0000,
	567	});
	568
	569	pub const Crc16OpensafetyB = Crc(u16, .{
	570	.polynomial = 0x755b,
	571	.initial = 0x0000,
	572	.reflect_input = false,
	573	.reflect_output = false,
	574	.xor_output = 0x0000,
	575	});
	576
	577	pub const Crc16Profibus = Crc(u16, .{
	578	.polynomial = 0x1dcf,
	579	.initial = 0xffff,
	580	.reflect_input = false,
	581	.reflect_output = false,
	582	.xor_output = 0xffff,
	583	});
	584
	585	pub const Crc16Riello = Crc(u16, .{
	586	.polynomial = 0x1021,
	587	.initial = 0xb2aa,
	588	.reflect_input = true,
	589	.reflect_output = true,
	590	.xor_output = 0x0000,
	591	});
	592
	593	pub const Crc16SpiFujitsu = Crc(u16, .{
	594	.polynomial = 0x1021,
	595	.initial = 0x1d0f,
	596	.reflect_input = false,
	597	.reflect_output = false,
	598	.xor_output = 0x0000,
	599	});
	600
	601	pub const Crc16T10Dif = Crc(u16, .{
	602	.polynomial = 0x8bb7,
	603	.initial = 0x0000,
	604	.reflect_input = false,
	605	.reflect_output = false,
	606	.xor_output = 0x0000,
	607	});
	608
	609	pub const Crc16Teledisk = Crc(u16, .{
	610	.polynomial = 0xa097,
	611	.initial = 0x0000,
	612	.reflect_input = false,
	613	.reflect_output = false,
	614	.xor_output = 0x0000,
	615	});
	616
	617	pub const Crc16Tms37157 = Crc(u16, .{
	618	.polynomial = 0x1021,
	619	.initial = 0x89ec,
	620	.reflect_input = true,
	621	.reflect_output = true,
	622	.xor_output = 0x0000,
	623	});
	624
	625	pub const Crc16Umts = Crc(u16, .{
	626	.polynomial = 0x8005,
	627	.initial = 0x0000,
	628	.reflect_input = false,
	629	.reflect_output = false,
	630	.xor_output = 0x0000,
	631	});
	632
	633	pub const Crc16Usb = Crc(u16, .{
	634	.polynomial = 0x8005,
	635	.initial = 0xffff,
	636	.reflect_input = true,
	637	.reflect_output = true,
	638	.xor_output = 0xffff,
	639	});
	640
	641	pub const Crc16Xmodem = Crc(u16, .{
	642	.polynomial = 0x1021,
	643	.initial = 0x0000,
	644	.reflect_input = false,
	645	.reflect_output = false,
	646	.xor_output = 0x0000,
	647	});
	648
	649	pub const Crc17CanFd = Crc(u17, .{
	650	.polynomial = 0x1685b,
	651	.initial = 0x00000,
	652	.reflect_input = false,
	653	.reflect_output = false,
	654	.xor_output = 0x00000,
	655	});
	656
	657	pub const Crc21CanFd = Crc(u21, .{
	658	.polynomial = 0x102899,
	659	.initial = 0x000000,
	660	.reflect_input = false,
	661	.reflect_output = false,
	662	.xor_output = 0x000000,
	663	});
	664
	665	pub const Crc24Ble = Crc(u24, .{
	666	.polynomial = 0x00065b,
	667	.initial = 0x555555,
	668	.reflect_input = true,
	669	.reflect_output = true,
	670	.xor_output = 0x000000,
	671	});
	672
	673	pub const Crc24FlexrayA = Crc(u24, .{
	674	.polynomial = 0x5d6dcb,
	675	.initial = 0xfedcba,
	676	.reflect_input = false,
	677	.reflect_output = false,
	678	.xor_output = 0x000000,
	679	});
	680
	681	pub const Crc24FlexrayB = Crc(u24, .{
	682	.polynomial = 0x5d6dcb,
	683	.initial = 0xabcdef,
	684	.reflect_input = false,
	685	.reflect_output = false,
	686	.xor_output = 0x000000,
	687	});
	688
	689	pub const Crc24Interlaken = Crc(u24, .{
	690	.polynomial = 0x328b63,
	691	.initial = 0xffffff,
	692	.reflect_input = false,
	693	.reflect_output = false,
	694	.xor_output = 0xffffff,
	695	});
	696
	697	pub const Crc24LteA = Crc(u24, .{
	698	.polynomial = 0x864cfb,
	699	.initial = 0x000000,
	700	.reflect_input = false,
	701	.reflect_output = false,
	702	.xor_output = 0x000000,
	703	});
	704
	705	pub const Crc24LteB = Crc(u24, .{
	706	.polynomial = 0x800063,
	707	.initial = 0x000000,
	708	.reflect_input = false,
	709	.reflect_output = false,
	710	.xor_output = 0x000000,
	711	});
	712
	713	pub const Crc24Openpgp = Crc(u24, .{
	714	.polynomial = 0x864cfb,
	715	.initial = 0xb704ce,
	716	.reflect_input = false,
	717	.reflect_output = false,
	718	.xor_output = 0x000000,
	719	});
	720
	721	pub const Crc24Os9 = Crc(u24, .{
	722	.polynomial = 0x800063,
	723	.initial = 0xffffff,
	724	.reflect_input = false,
	725	.reflect_output = false,
	726	.xor_output = 0xffffff,
	727	});
	728
	729	pub const Crc30Cdma = Crc(u30, .{
	730	.polynomial = 0x2030b9c7,
	731	.initial = 0x3fffffff,
	732	.reflect_input = false,
	733	.reflect_output = false,
	734	.xor_output = 0x3fffffff,
	735	});
	736
	737	pub const Crc31Philips = Crc(u31, .{
	738	.polynomial = 0x04c11db7,
	739	.initial = 0x7fffffff,
	740	.reflect_input = false,
	741	.reflect_output = false,
	742	.xor_output = 0x7fffffff,
	743	});
	744
	745	pub const Crc32Aixm = Crc(u32, .{
	746	.polynomial = 0x814141ab,
	747	.initial = 0x00000000,
	748	.reflect_input = false,
	749	.reflect_output = false,
	750	.xor_output = 0x00000000,
	751	});
	752
	753	pub const Crc32Autosar = Crc(u32, .{
	754	.polynomial = 0xf4acfb13,
	755	.initial = 0xffffffff,
	756	.reflect_input = true,
	757	.reflect_output = true,
	758	.xor_output = 0xffffffff,
	759	});
	760
	761	pub const Crc32Base91D = Crc(u32, .{
	762	.polynomial = 0xa833982b,
	763	.initial = 0xffffffff,
	764	.reflect_input = true,
	765	.reflect_output = true,
	766	.xor_output = 0xffffffff,
	767	});
	768
	769	pub const Crc32Bzip2 = Crc(u32, .{
	770	.polynomial = 0x04c11db7,
	771	.initial = 0xffffffff,
	772	.reflect_input = false,
	773	.reflect_output = false,
	774	.xor_output = 0xffffffff,
	775	});
	776
	777	pub const Crc32CdRomEdc = Crc(u32, .{
	778	.polynomial = 0x8001801b,
	779	.initial = 0x00000000,
	780	.reflect_input = true,
	781	.reflect_output = true,
	782	.xor_output = 0x00000000,
	783	});
	784
	785	pub const Crc32Cksum = Crc(u32, .{
	786	.polynomial = 0x04c11db7,
	787	.initial = 0x00000000,
	788	.reflect_input = false,
	789	.reflect_output = false,
	790	.xor_output = 0xffffffff,
	791	});
	792
	793	pub const Crc32Iscsi = Crc(u32, .{
	794	.polynomial = 0x1edc6f41,
	795	.initial = 0xffffffff,
	796	.reflect_input = true,
	797	.reflect_output = true,
	798	.xor_output = 0xffffffff,
	799	});
	800
	801	pub const Crc32IsoHdlc = Crc(u32, .{
	802	.polynomial = 0x04c11db7,
	803	.initial = 0xffffffff,
	804	.reflect_input = true,
	805	.reflect_output = true,
	806	.xor_output = 0xffffffff,
	807	});
	808
	809	pub const Crc32Jamcrc = Crc(u32, .{
	810	.polynomial = 0x04c11db7,
	811	.initial = 0xffffffff,
	812	.reflect_input = true,
	813	.reflect_output = true,
	814	.xor_output = 0x00000000,
	815	});
	816
	817	pub const Crc32Mef = Crc(u32, .{
	818	.polynomial = 0x741b8cd7,
	819	.initial = 0xffffffff,
	820	.reflect_input = true,
	821	.reflect_output = true,
	822	.xor_output = 0x00000000,
	823	});
	824
	825	pub const Crc32Mpeg2 = Crc(u32, .{
	826	.polynomial = 0x04c11db7,
	827	.initial = 0xffffffff,
	828	.reflect_input = false,
	829	.reflect_output = false,
	830	.xor_output = 0x00000000,
	831	});
	832
	833	pub const Crc32Xfer = Crc(u32, .{
	834	.polynomial = 0x000000af,
	835	.initial = 0x00000000,
	836	.reflect_input = false,
	837	.reflect_output = false,
	838	.xor_output = 0x00000000,
	839	});
	840
	841	pub const Crc40Gsm = Crc(u40, .{
	842	.polynomial = 0x0004820009,
	843	.initial = 0x0000000000,
	844	.reflect_input = false,
	845	.reflect_output = false,
	846	.xor_output = 0xffffffffff,
	847	});
	848
	849	pub const Crc64Ecma182 = Crc(u64, .{
	850	.polynomial = 0x42f0e1eba9ea3693,
	851	.initial = 0x0000000000000000,
	852	.reflect_input = false,
	853	.reflect_output = false,
	854	.xor_output = 0x0000000000000000,
	855	});
	856
	857	pub const Crc64GoIso = Crc(u64, .{
	858	.polynomial = 0x000000000000001b,
	859	.initial = 0xffffffffffffffff,
	860	.reflect_input = true,
	861	.reflect_output = true,
	862	.xor_output = 0xffffffffffffffff,
	863	});
	864
	865	pub const Crc64Ms = Crc(u64, .{
	866	.polynomial = 0x259c84cba6426349,
	867	.initial = 0xffffffffffffffff,
	868	.reflect_input = true,
	869	.reflect_output = true,
	870	.xor_output = 0x0000000000000000,
	871	});
	872
	873	pub const Crc64Redis = Crc(u64, .{
	874	.polynomial = 0xad93d23594c935a9,
	875	.initial = 0x0000000000000000,
	876	.reflect_input = true,
	877	.reflect_output = true,
	878	.xor_output = 0x0000000000000000,
	879	});
	880
	881	pub const Crc64We = Crc(u64, .{
	882	.polynomial = 0x42f0e1eba9ea3693,
	883	.initial = 0xffffffffffffffff,
	884	.reflect_input = false,
	885	.reflect_output = false,
	886	.xor_output = 0xffffffffffffffff,
	887	});
	888
	889	pub const Crc64Xz = Crc(u64, .{
	890	.polynomial = 0x42f0e1eba9ea3693,
	891	.initial = 0xffffffffffffffff,
	892	.reflect_input = true,
	893	.reflect_output = true,
	894	.xor_output = 0xffffffffffffffff,
	895	});
	896
	897	pub const Crc82Darc = Crc(u82, .{
	898	.polynomial = 0x0308c0111011401440411,
	899	.initial = 0x000000000000000000000,
	900	.reflect_input = true,
	901	.reflect_output = true,
	902	.xor_output = 0x000000000000000000000,
	903	});

lib/std/hash/crc/catalog_test.zig created+1237

...	...	@@ -0,0 +1,1237 @@
	1	//! This file is auto-generated by tools/update_crc_catalog.zig.
	2
	3	const std = @import("../../std.zig");
	4	const testing = std.testing;
	5	const catalog = @import("catalog.zig");
	6
	7	test "CRC-3/GSM" {
	8	const Crc3Gsm = catalog.Crc3Gsm;
	9
	10	try testing.expectEqual(@as(u3, 0x4), Crc3Gsm.hash("123456789"));
	11
	12	var c = Crc3Gsm.init();
	13	c.update("1234");
	14	c.update("56789");
	15	try testing.expectEqual(@as(u3, 0x4), c.final());
	16	}
	17
	18	test "CRC-3/ROHC" {
	19	const Crc3Rohc = catalog.Crc3Rohc;
	20
	21	try testing.expectEqual(@as(u3, 0x6), Crc3Rohc.hash("123456789"));
	22
	23	var c = Crc3Rohc.init();
	24	c.update("1234");
	25	c.update("56789");
	26	try testing.expectEqual(@as(u3, 0x6), c.final());
	27	}
	28
	29	test "CRC-4/G-704" {
	30	const Crc4G704 = catalog.Crc4G704;
	31
	32	try testing.expectEqual(@as(u4, 0x7), Crc4G704.hash("123456789"));
	33
	34	var c = Crc4G704.init();
	35	c.update("1234");
	36	c.update("56789");
	37	try testing.expectEqual(@as(u4, 0x7), c.final());
	38	}
	39
	40	test "CRC-4/INTERLAKEN" {
	41	const Crc4Interlaken = catalog.Crc4Interlaken;
	42
	43	try testing.expectEqual(@as(u4, 0xb), Crc4Interlaken.hash("123456789"));
	44
	45	var c = Crc4Interlaken.init();
	46	c.update("1234");
	47	c.update("56789");
	48	try testing.expectEqual(@as(u4, 0xb), c.final());
	49	}
	50
	51	test "CRC-5/EPC-C1G2" {
	52	const Crc5EpcC1g2 = catalog.Crc5EpcC1g2;
	53
	54	try testing.expectEqual(@as(u5, 0x00), Crc5EpcC1g2.hash("123456789"));
	55
	56	var c = Crc5EpcC1g2.init();
	57	c.update("1234");
	58	c.update("56789");
	59	try testing.expectEqual(@as(u5, 0x00), c.final());
	60	}
	61
	62	test "CRC-5/G-704" {
	63	const Crc5G704 = catalog.Crc5G704;
	64
	65	try testing.expectEqual(@as(u5, 0x07), Crc5G704.hash("123456789"));
	66
	67	var c = Crc5G704.init();
	68	c.update("1234");
	69	c.update("56789");
	70	try testing.expectEqual(@as(u5, 0x07), c.final());
	71	}
	72
	73	test "CRC-5/USB" {
	74	const Crc5Usb = catalog.Crc5Usb;
	75
	76	try testing.expectEqual(@as(u5, 0x19), Crc5Usb.hash("123456789"));
	77
	78	var c = Crc5Usb.init();
	79	c.update("1234");
	80	c.update("56789");
	81	try testing.expectEqual(@as(u5, 0x19), c.final());
	82	}
	83
	84	test "CRC-6/CDMA2000-A" {
	85	const Crc6Cdma2000A = catalog.Crc6Cdma2000A;
	86
	87	try testing.expectEqual(@as(u6, 0x0d), Crc6Cdma2000A.hash("123456789"));
	88
	89	var c = Crc6Cdma2000A.init();
	90	c.update("1234");
	91	c.update("56789");
	92	try testing.expectEqual(@as(u6, 0x0d), c.final());
	93	}
	94
	95	test "CRC-6/CDMA2000-B" {
	96	const Crc6Cdma2000B = catalog.Crc6Cdma2000B;
	97
	98	try testing.expectEqual(@as(u6, 0x3b), Crc6Cdma2000B.hash("123456789"));
	99
	100	var c = Crc6Cdma2000B.init();
	101	c.update("1234");
	102	c.update("56789");
	103	try testing.expectEqual(@as(u6, 0x3b), c.final());
	104	}
	105
	106	test "CRC-6/DARC" {
	107	const Crc6Darc = catalog.Crc6Darc;
	108
	109	try testing.expectEqual(@as(u6, 0x26), Crc6Darc.hash("123456789"));
	110
	111	var c = Crc6Darc.init();
	112	c.update("1234");
	113	c.update("56789");
	114	try testing.expectEqual(@as(u6, 0x26), c.final());
	115	}
	116
	117	test "CRC-6/G-704" {
	118	const Crc6G704 = catalog.Crc6G704;
	119
	120	try testing.expectEqual(@as(u6, 0x06), Crc6G704.hash("123456789"));
	121
	122	var c = Crc6G704.init();
	123	c.update("1234");
	124	c.update("56789");
	125	try testing.expectEqual(@as(u6, 0x06), c.final());
	126	}
	127
	128	test "CRC-6/GSM" {
	129	const Crc6Gsm = catalog.Crc6Gsm;
	130
	131	try testing.expectEqual(@as(u6, 0x13), Crc6Gsm.hash("123456789"));
	132
	133	var c = Crc6Gsm.init();
	134	c.update("1234");
	135	c.update("56789");
	136	try testing.expectEqual(@as(u6, 0x13), c.final());
	137	}
	138
	139	test "CRC-7/MMC" {
	140	const Crc7Mmc = catalog.Crc7Mmc;
	141
	142	try testing.expectEqual(@as(u7, 0x75), Crc7Mmc.hash("123456789"));
	143
	144	var c = Crc7Mmc.init();
	145	c.update("1234");
	146	c.update("56789");
	147	try testing.expectEqual(@as(u7, 0x75), c.final());
	148	}
	149
	150	test "CRC-7/ROHC" {
	151	const Crc7Rohc = catalog.Crc7Rohc;
	152
	153	try testing.expectEqual(@as(u7, 0x53), Crc7Rohc.hash("123456789"));
	154
	155	var c = Crc7Rohc.init();
	156	c.update("1234");
	157	c.update("56789");
	158	try testing.expectEqual(@as(u7, 0x53), c.final());
	159	}
	160
	161	test "CRC-7/UMTS" {
	162	const Crc7Umts = catalog.Crc7Umts;
	163
	164	try testing.expectEqual(@as(u7, 0x61), Crc7Umts.hash("123456789"));
	165
	166	var c = Crc7Umts.init();
	167	c.update("1234");
	168	c.update("56789");
	169	try testing.expectEqual(@as(u7, 0x61), c.final());
	170	}
	171
	172	test "CRC-8/AUTOSAR" {
	173	const Crc8Autosar = catalog.Crc8Autosar;
	174
	175	try testing.expectEqual(@as(u8, 0xdf), Crc8Autosar.hash("123456789"));
	176
	177	var c = Crc8Autosar.init();
	178	c.update("1234");
	179	c.update("56789");
	180	try testing.expectEqual(@as(u8, 0xdf), c.final());
	181	}
	182
	183	test "CRC-8/BLUETOOTH" {
	184	const Crc8Bluetooth = catalog.Crc8Bluetooth;
	185
	186	try testing.expectEqual(@as(u8, 0x26), Crc8Bluetooth.hash("123456789"));
	187
	188	var c = Crc8Bluetooth.init();
	189	c.update("1234");
	190	c.update("56789");
	191	try testing.expectEqual(@as(u8, 0x26), c.final());
	192	}
	193
	194	test "CRC-8/CDMA2000" {
	195	const Crc8Cdma2000 = catalog.Crc8Cdma2000;
	196
	197	try testing.expectEqual(@as(u8, 0xda), Crc8Cdma2000.hash("123456789"));
	198
	199	var c = Crc8Cdma2000.init();
	200	c.update("1234");
	201	c.update("56789");
	202	try testing.expectEqual(@as(u8, 0xda), c.final());
	203	}
	204
	205	test "CRC-8/DARC" {
	206	const Crc8Darc = catalog.Crc8Darc;
	207
	208	try testing.expectEqual(@as(u8, 0x15), Crc8Darc.hash("123456789"));
	209
	210	var c = Crc8Darc.init();
	211	c.update("1234");
	212	c.update("56789");
	213	try testing.expectEqual(@as(u8, 0x15), c.final());
	214	}
	215
	216	test "CRC-8/DVB-S2" {
	217	const Crc8DvbS2 = catalog.Crc8DvbS2;
	218
	219	try testing.expectEqual(@as(u8, 0xbc), Crc8DvbS2.hash("123456789"));
	220
	221	var c = Crc8DvbS2.init();
	222	c.update("1234");
	223	c.update("56789");
	224	try testing.expectEqual(@as(u8, 0xbc), c.final());
	225	}
	226
	227	test "CRC-8/GSM-A" {
	228	const Crc8GsmA = catalog.Crc8GsmA;
	229
	230	try testing.expectEqual(@as(u8, 0x37), Crc8GsmA.hash("123456789"));
	231
	232	var c = Crc8GsmA.init();
	233	c.update("1234");
	234	c.update("56789");
	235	try testing.expectEqual(@as(u8, 0x37), c.final());
	236	}
	237
	238	test "CRC-8/GSM-B" {
	239	const Crc8GsmB = catalog.Crc8GsmB;
	240
	241	try testing.expectEqual(@as(u8, 0x94), Crc8GsmB.hash("123456789"));
	242
	243	var c = Crc8GsmB.init();
	244	c.update("1234");
	245	c.update("56789");
	246	try testing.expectEqual(@as(u8, 0x94), c.final());
	247	}
	248
	249	test "CRC-8/HITAG" {
	250	const Crc8Hitag = catalog.Crc8Hitag;
	251
	252	try testing.expectEqual(@as(u8, 0xb4), Crc8Hitag.hash("123456789"));
	253
	254	var c = Crc8Hitag.init();
	255	c.update("1234");
	256	c.update("56789");
	257	try testing.expectEqual(@as(u8, 0xb4), c.final());
	258	}
	259
	260	test "CRC-8/I-432-1" {
	261	const Crc8I4321 = catalog.Crc8I4321;
	262
	263	try testing.expectEqual(@as(u8, 0xa1), Crc8I4321.hash("123456789"));
	264
	265	var c = Crc8I4321.init();
	266	c.update("1234");
	267	c.update("56789");
	268	try testing.expectEqual(@as(u8, 0xa1), c.final());
	269	}
	270
	271	test "CRC-8/I-CODE" {
	272	const Crc8ICode = catalog.Crc8ICode;
	273
	274	try testing.expectEqual(@as(u8, 0x7e), Crc8ICode.hash("123456789"));
	275
	276	var c = Crc8ICode.init();
	277	c.update("1234");
	278	c.update("56789");
	279	try testing.expectEqual(@as(u8, 0x7e), c.final());
	280	}
	281
	282	test "CRC-8/LTE" {
	283	const Crc8Lte = catalog.Crc8Lte;
	284
	285	try testing.expectEqual(@as(u8, 0xea), Crc8Lte.hash("123456789"));
	286
	287	var c = Crc8Lte.init();
	288	c.update("1234");
	289	c.update("56789");
	290	try testing.expectEqual(@as(u8, 0xea), c.final());
	291	}
	292
	293	test "CRC-8/MAXIM-DOW" {
	294	const Crc8MaximDow = catalog.Crc8MaximDow;
	295
	296	try testing.expectEqual(@as(u8, 0xa1), Crc8MaximDow.hash("123456789"));
	297
	298	var c = Crc8MaximDow.init();
	299	c.update("1234");
	300	c.update("56789");
	301	try testing.expectEqual(@as(u8, 0xa1), c.final());
	302	}
	303
	304	test "CRC-8/MIFARE-MAD" {
	305	const Crc8MifareMad = catalog.Crc8MifareMad;
	306
	307	try testing.expectEqual(@as(u8, 0x99), Crc8MifareMad.hash("123456789"));
	308
	309	var c = Crc8MifareMad.init();
	310	c.update("1234");
	311	c.update("56789");
	312	try testing.expectEqual(@as(u8, 0x99), c.final());
	313	}
	314
	315	test "CRC-8/NRSC-5" {
	316	const Crc8Nrsc5 = catalog.Crc8Nrsc5;
	317
	318	try testing.expectEqual(@as(u8, 0xf7), Crc8Nrsc5.hash("123456789"));
	319
	320	var c = Crc8Nrsc5.init();
	321	c.update("1234");
	322	c.update("56789");
	323	try testing.expectEqual(@as(u8, 0xf7), c.final());
	324	}
	325
	326	test "CRC-8/OPENSAFETY" {
	327	const Crc8Opensafety = catalog.Crc8Opensafety;
	328
	329	try testing.expectEqual(@as(u8, 0x3e), Crc8Opensafety.hash("123456789"));
	330
	331	var c = Crc8Opensafety.init();
	332	c.update("1234");
	333	c.update("56789");
	334	try testing.expectEqual(@as(u8, 0x3e), c.final());
	335	}
	336
	337	test "CRC-8/ROHC" {
	338	const Crc8Rohc = catalog.Crc8Rohc;
	339
	340	try testing.expectEqual(@as(u8, 0xd0), Crc8Rohc.hash("123456789"));
	341
	342	var c = Crc8Rohc.init();
	343	c.update("1234");
	344	c.update("56789");
	345	try testing.expectEqual(@as(u8, 0xd0), c.final());
	346	}
	347
	348	test "CRC-8/SAE-J1850" {
	349	const Crc8SaeJ1850 = catalog.Crc8SaeJ1850;
	350
	351	try testing.expectEqual(@as(u8, 0x4b), Crc8SaeJ1850.hash("123456789"));
	352
	353	var c = Crc8SaeJ1850.init();
	354	c.update("1234");
	355	c.update("56789");
	356	try testing.expectEqual(@as(u8, 0x4b), c.final());
	357	}
	358
	359	test "CRC-8/SMBUS" {
	360	const Crc8Smbus = catalog.Crc8Smbus;
	361
	362	try testing.expectEqual(@as(u8, 0xf4), Crc8Smbus.hash("123456789"));
	363
	364	var c = Crc8Smbus.init();
	365	c.update("1234");
	366	c.update("56789");
	367	try testing.expectEqual(@as(u8, 0xf4), c.final());
	368	}
	369
	370	test "CRC-8/TECH-3250" {
	371	const Crc8Tech3250 = catalog.Crc8Tech3250;
	372
	373	try testing.expectEqual(@as(u8, 0x97), Crc8Tech3250.hash("123456789"));
	374
	375	var c = Crc8Tech3250.init();
	376	c.update("1234");
	377	c.update("56789");
	378	try testing.expectEqual(@as(u8, 0x97), c.final());
	379	}
	380
	381	test "CRC-8/WCDMA" {
	382	const Crc8Wcdma = catalog.Crc8Wcdma;
	383
	384	try testing.expectEqual(@as(u8, 0x25), Crc8Wcdma.hash("123456789"));
	385
	386	var c = Crc8Wcdma.init();
	387	c.update("1234");
	388	c.update("56789");
	389	try testing.expectEqual(@as(u8, 0x25), c.final());
	390	}
	391
	392	test "CRC-10/ATM" {
	393	const Crc10Atm = catalog.Crc10Atm;
	394
	395	try testing.expectEqual(@as(u10, 0x199), Crc10Atm.hash("123456789"));
	396
	397	var c = Crc10Atm.init();
	398	c.update("1234");
	399	c.update("56789");
	400	try testing.expectEqual(@as(u10, 0x199), c.final());
	401	}
	402
	403	test "CRC-10/CDMA2000" {
	404	const Crc10Cdma2000 = catalog.Crc10Cdma2000;
	405
	406	try testing.expectEqual(@as(u10, 0x233), Crc10Cdma2000.hash("123456789"));
	407
	408	var c = Crc10Cdma2000.init();
	409	c.update("1234");
	410	c.update("56789");
	411	try testing.expectEqual(@as(u10, 0x233), c.final());
	412	}
	413
	414	test "CRC-10/GSM" {
	415	const Crc10Gsm = catalog.Crc10Gsm;
	416
	417	try testing.expectEqual(@as(u10, 0x12a), Crc10Gsm.hash("123456789"));
	418
	419	var c = Crc10Gsm.init();
	420	c.update("1234");
	421	c.update("56789");
	422	try testing.expectEqual(@as(u10, 0x12a), c.final());
	423	}
	424
	425	test "CRC-11/FLEXRAY" {
	426	const Crc11Flexray = catalog.Crc11Flexray;
	427
	428	try testing.expectEqual(@as(u11, 0x5a3), Crc11Flexray.hash("123456789"));
	429
	430	var c = Crc11Flexray.init();
	431	c.update("1234");
	432	c.update("56789");
	433	try testing.expectEqual(@as(u11, 0x5a3), c.final());
	434	}
	435
	436	test "CRC-11/UMTS" {
	437	const Crc11Umts = catalog.Crc11Umts;
	438
	439	try testing.expectEqual(@as(u11, 0x061), Crc11Umts.hash("123456789"));
	440
	441	var c = Crc11Umts.init();
	442	c.update("1234");
	443	c.update("56789");
	444	try testing.expectEqual(@as(u11, 0x061), c.final());
	445	}
	446
	447	test "CRC-12/CDMA2000" {
	448	const Crc12Cdma2000 = catalog.Crc12Cdma2000;
	449
	450	try testing.expectEqual(@as(u12, 0xd4d), Crc12Cdma2000.hash("123456789"));
	451
	452	var c = Crc12Cdma2000.init();
	453	c.update("1234");
	454	c.update("56789");
	455	try testing.expectEqual(@as(u12, 0xd4d), c.final());
	456	}
	457
	458	test "CRC-12/DECT" {
	459	const Crc12Dect = catalog.Crc12Dect;
	460
	461	try testing.expectEqual(@as(u12, 0xf5b), Crc12Dect.hash("123456789"));
	462
	463	var c = Crc12Dect.init();
	464	c.update("1234");
	465	c.update("56789");
	466	try testing.expectEqual(@as(u12, 0xf5b), c.final());
	467	}
	468
	469	test "CRC-12/GSM" {
	470	const Crc12Gsm = catalog.Crc12Gsm;
	471
	472	try testing.expectEqual(@as(u12, 0xb34), Crc12Gsm.hash("123456789"));
	473
	474	var c = Crc12Gsm.init();
	475	c.update("1234");
	476	c.update("56789");
	477	try testing.expectEqual(@as(u12, 0xb34), c.final());
	478	}
	479
	480	test "CRC-12/UMTS" {
	481	const Crc12Umts = catalog.Crc12Umts;
	482
	483	try testing.expectEqual(@as(u12, 0xdaf), Crc12Umts.hash("123456789"));
	484
	485	var c = Crc12Umts.init();
	486	c.update("1234");
	487	c.update("56789");
	488	try testing.expectEqual(@as(u12, 0xdaf), c.final());
	489	}
	490
	491	test "CRC-13/BBC" {
	492	const Crc13Bbc = catalog.Crc13Bbc;
	493
	494	try testing.expectEqual(@as(u13, 0x04fa), Crc13Bbc.hash("123456789"));
	495
	496	var c = Crc13Bbc.init();
	497	c.update("1234");
	498	c.update("56789");
	499	try testing.expectEqual(@as(u13, 0x04fa), c.final());
	500	}
	501
	502	test "CRC-14/DARC" {
	503	const Crc14Darc = catalog.Crc14Darc;
	504
	505	try testing.expectEqual(@as(u14, 0x082d), Crc14Darc.hash("123456789"));
	506
	507	var c = Crc14Darc.init();
	508	c.update("1234");
	509	c.update("56789");
	510	try testing.expectEqual(@as(u14, 0x082d), c.final());
	511	}
	512
	513	test "CRC-14/GSM" {
	514	const Crc14Gsm = catalog.Crc14Gsm;
	515
	516	try testing.expectEqual(@as(u14, 0x30ae), Crc14Gsm.hash("123456789"));
	517
	518	var c = Crc14Gsm.init();
	519	c.update("1234");
	520	c.update("56789");
	521	try testing.expectEqual(@as(u14, 0x30ae), c.final());
	522	}
	523
	524	test "CRC-15/CAN" {
	525	const Crc15Can = catalog.Crc15Can;
	526
	527	try testing.expectEqual(@as(u15, 0x059e), Crc15Can.hash("123456789"));
	528
	529	var c = Crc15Can.init();
	530	c.update("1234");
	531	c.update("56789");
	532	try testing.expectEqual(@as(u15, 0x059e), c.final());
	533	}
	534
	535	test "CRC-15/MPT1327" {
	536	const Crc15Mpt1327 = catalog.Crc15Mpt1327;
	537
	538	try testing.expectEqual(@as(u15, 0x2566), Crc15Mpt1327.hash("123456789"));
	539
	540	var c = Crc15Mpt1327.init();
	541	c.update("1234");
	542	c.update("56789");
	543	try testing.expectEqual(@as(u15, 0x2566), c.final());
	544	}
	545
	546	test "CRC-16/ARC" {
	547	const Crc16Arc = catalog.Crc16Arc;
	548
	549	try testing.expectEqual(@as(u16, 0xbb3d), Crc16Arc.hash("123456789"));
	550
	551	var c = Crc16Arc.init();
	552	c.update("1234");
	553	c.update("56789");
	554	try testing.expectEqual(@as(u16, 0xbb3d), c.final());
	555	}
	556
	557	test "CRC-16/CDMA2000" {
	558	const Crc16Cdma2000 = catalog.Crc16Cdma2000;
	559
	560	try testing.expectEqual(@as(u16, 0x4c06), Crc16Cdma2000.hash("123456789"));
	561
	562	var c = Crc16Cdma2000.init();
	563	c.update("1234");
	564	c.update("56789");
	565	try testing.expectEqual(@as(u16, 0x4c06), c.final());
	566	}
	567
	568	test "CRC-16/CMS" {
	569	const Crc16Cms = catalog.Crc16Cms;
	570
	571	try testing.expectEqual(@as(u16, 0xaee7), Crc16Cms.hash("123456789"));
	572
	573	var c = Crc16Cms.init();
	574	c.update("1234");
	575	c.update("56789");
	576	try testing.expectEqual(@as(u16, 0xaee7), c.final());
	577	}
	578
	579	test "CRC-16/DDS-110" {
	580	const Crc16Dds110 = catalog.Crc16Dds110;
	581
	582	try testing.expectEqual(@as(u16, 0x9ecf), Crc16Dds110.hash("123456789"));
	583
	584	var c = Crc16Dds110.init();
	585	c.update("1234");
	586	c.update("56789");
	587	try testing.expectEqual(@as(u16, 0x9ecf), c.final());
	588	}
	589
	590	test "CRC-16/DECT-R" {
	591	const Crc16DectR = catalog.Crc16DectR;
	592
	593	try testing.expectEqual(@as(u16, 0x007e), Crc16DectR.hash("123456789"));
	594
	595	var c = Crc16DectR.init();
	596	c.update("1234");
	597	c.update("56789");
	598	try testing.expectEqual(@as(u16, 0x007e), c.final());
	599	}
	600
	601	test "CRC-16/DECT-X" {
	602	const Crc16DectX = catalog.Crc16DectX;
	603
	604	try testing.expectEqual(@as(u16, 0x007f), Crc16DectX.hash("123456789"));
	605
	606	var c = Crc16DectX.init();
	607	c.update("1234");
	608	c.update("56789");
	609	try testing.expectEqual(@as(u16, 0x007f), c.final());
	610	}
	611
	612	test "CRC-16/DNP" {
	613	const Crc16Dnp = catalog.Crc16Dnp;
	614
	615	try testing.expectEqual(@as(u16, 0xea82), Crc16Dnp.hash("123456789"));
	616
	617	var c = Crc16Dnp.init();
	618	c.update("1234");
	619	c.update("56789");
	620	try testing.expectEqual(@as(u16, 0xea82), c.final());
	621	}
	622
	623	test "CRC-16/EN-13757" {
	624	const Crc16En13757 = catalog.Crc16En13757;
	625
	626	try testing.expectEqual(@as(u16, 0xc2b7), Crc16En13757.hash("123456789"));
	627
	628	var c = Crc16En13757.init();
	629	c.update("1234");
	630	c.update("56789");
	631	try testing.expectEqual(@as(u16, 0xc2b7), c.final());
	632	}
	633
	634	test "CRC-16/GENIBUS" {
	635	const Crc16Genibus = catalog.Crc16Genibus;
	636
	637	try testing.expectEqual(@as(u16, 0xd64e), Crc16Genibus.hash("123456789"));
	638
	639	var c = Crc16Genibus.init();
	640	c.update("1234");
	641	c.update("56789");
	642	try testing.expectEqual(@as(u16, 0xd64e), c.final());
	643	}
	644
	645	test "CRC-16/GSM" {
	646	const Crc16Gsm = catalog.Crc16Gsm;
	647
	648	try testing.expectEqual(@as(u16, 0xce3c), Crc16Gsm.hash("123456789"));
	649
	650	var c = Crc16Gsm.init();
	651	c.update("1234");
	652	c.update("56789");
	653	try testing.expectEqual(@as(u16, 0xce3c), c.final());
	654	}
	655
	656	test "CRC-16/IBM-3740" {
	657	const Crc16Ibm3740 = catalog.Crc16Ibm3740;
	658
	659	try testing.expectEqual(@as(u16, 0x29b1), Crc16Ibm3740.hash("123456789"));
	660
	661	var c = Crc16Ibm3740.init();
	662	c.update("1234");
	663	c.update("56789");
	664	try testing.expectEqual(@as(u16, 0x29b1), c.final());
	665	}
	666
	667	test "CRC-16/IBM-SDLC" {
	668	const Crc16IbmSdlc = catalog.Crc16IbmSdlc;
	669
	670	try testing.expectEqual(@as(u16, 0x906e), Crc16IbmSdlc.hash("123456789"));
	671
	672	var c = Crc16IbmSdlc.init();
	673	c.update("1234");
	674	c.update("56789");
	675	try testing.expectEqual(@as(u16, 0x906e), c.final());
	676	}
	677
	678	test "CRC-16/ISO-IEC-14443-3-A" {
	679	const Crc16IsoIec144433A = catalog.Crc16IsoIec144433A;
	680
	681	try testing.expectEqual(@as(u16, 0xbf05), Crc16IsoIec144433A.hash("123456789"));
	682
	683	var c = Crc16IsoIec144433A.init();
	684	c.update("1234");
	685	c.update("56789");
	686	try testing.expectEqual(@as(u16, 0xbf05), c.final());
	687	}
	688
	689	test "CRC-16/KERMIT" {
	690	const Crc16Kermit = catalog.Crc16Kermit;
	691
	692	try testing.expectEqual(@as(u16, 0x2189), Crc16Kermit.hash("123456789"));
	693
	694	var c = Crc16Kermit.init();
	695	c.update("1234");
	696	c.update("56789");
	697	try testing.expectEqual(@as(u16, 0x2189), c.final());
	698	}
	699
	700	test "CRC-16/LJ1200" {
	701	const Crc16Lj1200 = catalog.Crc16Lj1200;
	702
	703	try testing.expectEqual(@as(u16, 0xbdf4), Crc16Lj1200.hash("123456789"));
	704
	705	var c = Crc16Lj1200.init();
	706	c.update("1234");
	707	c.update("56789");
	708	try testing.expectEqual(@as(u16, 0xbdf4), c.final());
	709	}
	710
	711	test "CRC-16/M17" {
	712	const Crc16M17 = catalog.Crc16M17;
	713
	714	try testing.expectEqual(@as(u16, 0x772b), Crc16M17.hash("123456789"));
	715
	716	var c = Crc16M17.init();
	717	c.update("1234");
	718	c.update("56789");
	719	try testing.expectEqual(@as(u16, 0x772b), c.final());
	720	}
	721
	722	test "CRC-16/MAXIM-DOW" {
	723	const Crc16MaximDow = catalog.Crc16MaximDow;
	724
	725	try testing.expectEqual(@as(u16, 0x44c2), Crc16MaximDow.hash("123456789"));
	726
	727	var c = Crc16MaximDow.init();
	728	c.update("1234");
	729	c.update("56789");
	730	try testing.expectEqual(@as(u16, 0x44c2), c.final());
	731	}
	732
	733	test "CRC-16/MCRF4XX" {
	734	const Crc16Mcrf4xx = catalog.Crc16Mcrf4xx;
	735
	736	try testing.expectEqual(@as(u16, 0x6f91), Crc16Mcrf4xx.hash("123456789"));
	737
	738	var c = Crc16Mcrf4xx.init();
	739	c.update("1234");
	740	c.update("56789");
	741	try testing.expectEqual(@as(u16, 0x6f91), c.final());
	742	}
	743
	744	test "CRC-16/MODBUS" {
	745	const Crc16Modbus = catalog.Crc16Modbus;
	746
	747	try testing.expectEqual(@as(u16, 0x4b37), Crc16Modbus.hash("123456789"));
	748
	749	var c = Crc16Modbus.init();
	750	c.update("1234");
	751	c.update("56789");
	752	try testing.expectEqual(@as(u16, 0x4b37), c.final());
	753	}
	754
	755	test "CRC-16/NRSC-5" {
	756	const Crc16Nrsc5 = catalog.Crc16Nrsc5;
	757
	758	try testing.expectEqual(@as(u16, 0xa066), Crc16Nrsc5.hash("123456789"));
	759
	760	var c = Crc16Nrsc5.init();
	761	c.update("1234");
	762	c.update("56789");
	763	try testing.expectEqual(@as(u16, 0xa066), c.final());
	764	}
	765
	766	test "CRC-16/OPENSAFETY-A" {
	767	const Crc16OpensafetyA = catalog.Crc16OpensafetyA;
	768
	769	try testing.expectEqual(@as(u16, 0x5d38), Crc16OpensafetyA.hash("123456789"));
	770
	771	var c = Crc16OpensafetyA.init();
	772	c.update("1234");
	773	c.update("56789");
	774	try testing.expectEqual(@as(u16, 0x5d38), c.final());
	775	}
	776
	777	test "CRC-16/OPENSAFETY-B" {
	778	const Crc16OpensafetyB = catalog.Crc16OpensafetyB;
	779
	780	try testing.expectEqual(@as(u16, 0x20fe), Crc16OpensafetyB.hash("123456789"));
	781
	782	var c = Crc16OpensafetyB.init();
	783	c.update("1234");
	784	c.update("56789");
	785	try testing.expectEqual(@as(u16, 0x20fe), c.final());
	786	}
	787
	788	test "CRC-16/PROFIBUS" {
	789	const Crc16Profibus = catalog.Crc16Profibus;
	790
	791	try testing.expectEqual(@as(u16, 0xa819), Crc16Profibus.hash("123456789"));
	792
	793	var c = Crc16Profibus.init();
	794	c.update("1234");
	795	c.update("56789");
	796	try testing.expectEqual(@as(u16, 0xa819), c.final());
	797	}
	798
	799	test "CRC-16/RIELLO" {
	800	const Crc16Riello = catalog.Crc16Riello;
	801
	802	try testing.expectEqual(@as(u16, 0x63d0), Crc16Riello.hash("123456789"));
	803
	804	var c = Crc16Riello.init();
	805	c.update("1234");
	806	c.update("56789");
	807	try testing.expectEqual(@as(u16, 0x63d0), c.final());
	808	}
	809
	810	test "CRC-16/SPI-FUJITSU" {
	811	const Crc16SpiFujitsu = catalog.Crc16SpiFujitsu;
	812
	813	try testing.expectEqual(@as(u16, 0xe5cc), Crc16SpiFujitsu.hash("123456789"));
	814
	815	var c = Crc16SpiFujitsu.init();
	816	c.update("1234");
	817	c.update("56789");
	818	try testing.expectEqual(@as(u16, 0xe5cc), c.final());
	819	}
	820
	821	test "CRC-16/T10-DIF" {
	822	const Crc16T10Dif = catalog.Crc16T10Dif;
	823
	824	try testing.expectEqual(@as(u16, 0xd0db), Crc16T10Dif.hash("123456789"));
	825
	826	var c = Crc16T10Dif.init();
	827	c.update("1234");
	828	c.update("56789");
	829	try testing.expectEqual(@as(u16, 0xd0db), c.final());
	830	}
	831
	832	test "CRC-16/TELEDISK" {
	833	const Crc16Teledisk = catalog.Crc16Teledisk;
	834
	835	try testing.expectEqual(@as(u16, 0x0fb3), Crc16Teledisk.hash("123456789"));
	836
	837	var c = Crc16Teledisk.init();
	838	c.update("1234");
	839	c.update("56789");
	840	try testing.expectEqual(@as(u16, 0x0fb3), c.final());
	841	}
	842
	843	test "CRC-16/TMS37157" {
	844	const Crc16Tms37157 = catalog.Crc16Tms37157;
	845
	846	try testing.expectEqual(@as(u16, 0x26b1), Crc16Tms37157.hash("123456789"));
	847
	848	var c = Crc16Tms37157.init();
	849	c.update("1234");
	850	c.update("56789");
	851	try testing.expectEqual(@as(u16, 0x26b1), c.final());
	852	}
	853
	854	test "CRC-16/UMTS" {
	855	const Crc16Umts = catalog.Crc16Umts;
	856
	857	try testing.expectEqual(@as(u16, 0xfee8), Crc16Umts.hash("123456789"));
	858
	859	var c = Crc16Umts.init();
	860	c.update("1234");
	861	c.update("56789");
	862	try testing.expectEqual(@as(u16, 0xfee8), c.final());
	863	}
	864
	865	test "CRC-16/USB" {
	866	const Crc16Usb = catalog.Crc16Usb;
	867
	868	try testing.expectEqual(@as(u16, 0xb4c8), Crc16Usb.hash("123456789"));
	869
	870	var c = Crc16Usb.init();
	871	c.update("1234");
	872	c.update("56789");
	873	try testing.expectEqual(@as(u16, 0xb4c8), c.final());
	874	}
	875
	876	test "CRC-16/XMODEM" {
	877	const Crc16Xmodem = catalog.Crc16Xmodem;
	878
	879	try testing.expectEqual(@as(u16, 0x31c3), Crc16Xmodem.hash("123456789"));
	880
	881	var c = Crc16Xmodem.init();
	882	c.update("1234");
	883	c.update("56789");
	884	try testing.expectEqual(@as(u16, 0x31c3), c.final());
	885	}
	886
	887	test "CRC-17/CAN-FD" {
	888	const Crc17CanFd = catalog.Crc17CanFd;
	889
	890	try testing.expectEqual(@as(u17, 0x04f03), Crc17CanFd.hash("123456789"));
	891
	892	var c = Crc17CanFd.init();
	893	c.update("1234");
	894	c.update("56789");
	895	try testing.expectEqual(@as(u17, 0x04f03), c.final());
	896	}
	897
	898	test "CRC-21/CAN-FD" {
	899	const Crc21CanFd = catalog.Crc21CanFd;
	900
	901	try testing.expectEqual(@as(u21, 0x0ed841), Crc21CanFd.hash("123456789"));
	902
	903	var c = Crc21CanFd.init();
	904	c.update("1234");
	905	c.update("56789");
	906	try testing.expectEqual(@as(u21, 0x0ed841), c.final());
	907	}
	908
	909	test "CRC-24/BLE" {
	910	const Crc24Ble = catalog.Crc24Ble;
	911
	912	try testing.expectEqual(@as(u24, 0xc25a56), Crc24Ble.hash("123456789"));
	913
	914	var c = Crc24Ble.init();
	915	c.update("1234");
	916	c.update("56789");
	917	try testing.expectEqual(@as(u24, 0xc25a56), c.final());
	918	}
	919
	920	test "CRC-24/FLEXRAY-A" {
	921	const Crc24FlexrayA = catalog.Crc24FlexrayA;
	922
	923	try testing.expectEqual(@as(u24, 0x7979bd), Crc24FlexrayA.hash("123456789"));
	924
	925	var c = Crc24FlexrayA.init();
	926	c.update("1234");
	927	c.update("56789");
	928	try testing.expectEqual(@as(u24, 0x7979bd), c.final());
	929	}
	930
	931	test "CRC-24/FLEXRAY-B" {
	932	const Crc24FlexrayB = catalog.Crc24FlexrayB;
	933
	934	try testing.expectEqual(@as(u24, 0x1f23b8), Crc24FlexrayB.hash("123456789"));
	935
	936	var c = Crc24FlexrayB.init();
	937	c.update("1234");
	938	c.update("56789");
	939	try testing.expectEqual(@as(u24, 0x1f23b8), c.final());
	940	}
	941
	942	test "CRC-24/INTERLAKEN" {
	943	const Crc24Interlaken = catalog.Crc24Interlaken;
	944
	945	try testing.expectEqual(@as(u24, 0xb4f3e6), Crc24Interlaken.hash("123456789"));
	946
	947	var c = Crc24Interlaken.init();
	948	c.update("1234");
	949	c.update("56789");
	950	try testing.expectEqual(@as(u24, 0xb4f3e6), c.final());
	951	}
	952
	953	test "CRC-24/LTE-A" {
	954	const Crc24LteA = catalog.Crc24LteA;
	955
	956	try testing.expectEqual(@as(u24, 0xcde703), Crc24LteA.hash("123456789"));
	957
	958	var c = Crc24LteA.init();
	959	c.update("1234");
	960	c.update("56789");
	961	try testing.expectEqual(@as(u24, 0xcde703), c.final());
	962	}
	963
	964	test "CRC-24/LTE-B" {
	965	const Crc24LteB = catalog.Crc24LteB;
	966
	967	try testing.expectEqual(@as(u24, 0x23ef52), Crc24LteB.hash("123456789"));
	968
	969	var c = Crc24LteB.init();
	970	c.update("1234");
	971	c.update("56789");
	972	try testing.expectEqual(@as(u24, 0x23ef52), c.final());
	973	}
	974
	975	test "CRC-24/OPENPGP" {
	976	const Crc24Openpgp = catalog.Crc24Openpgp;
	977
	978	try testing.expectEqual(@as(u24, 0x21cf02), Crc24Openpgp.hash("123456789"));
	979
	980	var c = Crc24Openpgp.init();
	981	c.update("1234");
	982	c.update("56789");
	983	try testing.expectEqual(@as(u24, 0x21cf02), c.final());
	984	}
	985
	986	test "CRC-24/OS-9" {
	987	const Crc24Os9 = catalog.Crc24Os9;
	988
	989	try testing.expectEqual(@as(u24, 0x200fa5), Crc24Os9.hash("123456789"));
	990
	991	var c = Crc24Os9.init();
	992	c.update("1234");
	993	c.update("56789");
	994	try testing.expectEqual(@as(u24, 0x200fa5), c.final());
	995	}
	996
	997	test "CRC-30/CDMA" {
	998	const Crc30Cdma = catalog.Crc30Cdma;
	999
	1000	try testing.expectEqual(@as(u30, 0x04c34abf), Crc30Cdma.hash("123456789"));
	1001
	1002	var c = Crc30Cdma.init();
	1003	c.update("1234");
	1004	c.update("56789");
	1005	try testing.expectEqual(@as(u30, 0x04c34abf), c.final());
	1006	}
	1007
	1008	test "CRC-31/PHILIPS" {
	1009	const Crc31Philips = catalog.Crc31Philips;
	1010
	1011	try testing.expectEqual(@as(u31, 0x0ce9e46c), Crc31Philips.hash("123456789"));
	1012
	1013	var c = Crc31Philips.init();
	1014	c.update("1234");
	1015	c.update("56789");
	1016	try testing.expectEqual(@as(u31, 0x0ce9e46c), c.final());
	1017	}
	1018
	1019	test "CRC-32/AIXM" {
	1020	const Crc32Aixm = catalog.Crc32Aixm;
	1021
	1022	try testing.expectEqual(@as(u32, 0x3010bf7f), Crc32Aixm.hash("123456789"));
	1023
	1024	var c = Crc32Aixm.init();
	1025	c.update("1234");
	1026	c.update("56789");
	1027	try testing.expectEqual(@as(u32, 0x3010bf7f), c.final());
	1028	}
	1029
	1030	test "CRC-32/AUTOSAR" {
	1031	const Crc32Autosar = catalog.Crc32Autosar;
	1032
	1033	try testing.expectEqual(@as(u32, 0x1697d06a), Crc32Autosar.hash("123456789"));
	1034
	1035	var c = Crc32Autosar.init();
	1036	c.update("1234");
	1037	c.update("56789");
	1038	try testing.expectEqual(@as(u32, 0x1697d06a), c.final());
	1039	}
	1040
	1041	test "CRC-32/BASE91-D" {
	1042	const Crc32Base91D = catalog.Crc32Base91D;
	1043
	1044	try testing.expectEqual(@as(u32, 0x87315576), Crc32Base91D.hash("123456789"));
	1045
	1046	var c = Crc32Base91D.init();
	1047	c.update("1234");
	1048	c.update("56789");
	1049	try testing.expectEqual(@as(u32, 0x87315576), c.final());
	1050	}
	1051
	1052	test "CRC-32/BZIP2" {
	1053	const Crc32Bzip2 = catalog.Crc32Bzip2;
	1054
	1055	try testing.expectEqual(@as(u32, 0xfc891918), Crc32Bzip2.hash("123456789"));
	1056
	1057	var c = Crc32Bzip2.init();
	1058	c.update("1234");
	1059	c.update("56789");
	1060	try testing.expectEqual(@as(u32, 0xfc891918), c.final());
	1061	}
	1062
	1063	test "CRC-32/CD-ROM-EDC" {
	1064	const Crc32CdRomEdc = catalog.Crc32CdRomEdc;
	1065
	1066	try testing.expectEqual(@as(u32, 0x6ec2edc4), Crc32CdRomEdc.hash("123456789"));
	1067
	1068	var c = Crc32CdRomEdc.init();
	1069	c.update("1234");
	1070	c.update("56789");
	1071	try testing.expectEqual(@as(u32, 0x6ec2edc4), c.final());
	1072	}
	1073
	1074	test "CRC-32/CKSUM" {
	1075	const Crc32Cksum = catalog.Crc32Cksum;
	1076
	1077	try testing.expectEqual(@as(u32, 0x765e7680), Crc32Cksum.hash("123456789"));
	1078
	1079	var c = Crc32Cksum.init();
	1080	c.update("1234");
	1081	c.update("56789");
	1082	try testing.expectEqual(@as(u32, 0x765e7680), c.final());
	1083	}
	1084
	1085	test "CRC-32/ISCSI" {
	1086	const Crc32Iscsi = catalog.Crc32Iscsi;
	1087
	1088	try testing.expectEqual(@as(u32, 0xe3069283), Crc32Iscsi.hash("123456789"));
	1089
	1090	var c = Crc32Iscsi.init();
	1091	c.update("1234");
	1092	c.update("56789");
	1093	try testing.expectEqual(@as(u32, 0xe3069283), c.final());
	1094	}
	1095
	1096	test "CRC-32/ISO-HDLC" {
	1097	const Crc32IsoHdlc = catalog.Crc32IsoHdlc;
	1098
	1099	try testing.expectEqual(@as(u32, 0xcbf43926), Crc32IsoHdlc.hash("123456789"));
	1100
	1101	var c = Crc32IsoHdlc.init();
	1102	c.update("1234");
	1103	c.update("56789");
	1104	try testing.expectEqual(@as(u32, 0xcbf43926), c.final());
	1105	}
	1106
	1107	test "CRC-32/JAMCRC" {
	1108	const Crc32Jamcrc = catalog.Crc32Jamcrc;
	1109
	1110	try testing.expectEqual(@as(u32, 0x340bc6d9), Crc32Jamcrc.hash("123456789"));
	1111
	1112	var c = Crc32Jamcrc.init();
	1113	c.update("1234");
	1114	c.update("56789");
	1115	try testing.expectEqual(@as(u32, 0x340bc6d9), c.final());
	1116	}
	1117
	1118	test "CRC-32/MEF" {
	1119	const Crc32Mef = catalog.Crc32Mef;
	1120
	1121	try testing.expectEqual(@as(u32, 0xd2c22f51), Crc32Mef.hash("123456789"));
	1122
	1123	var c = Crc32Mef.init();
	1124	c.update("1234");
	1125	c.update("56789");
	1126	try testing.expectEqual(@as(u32, 0xd2c22f51), c.final());
	1127	}
	1128
	1129	test "CRC-32/MPEG-2" {
	1130	const Crc32Mpeg2 = catalog.Crc32Mpeg2;
	1131
	1132	try testing.expectEqual(@as(u32, 0x0376e6e7), Crc32Mpeg2.hash("123456789"));
	1133
	1134	var c = Crc32Mpeg2.init();
	1135	c.update("1234");
	1136	c.update("56789");
	1137	try testing.expectEqual(@as(u32, 0x0376e6e7), c.final());
	1138	}
	1139
	1140	test "CRC-32/XFER" {
	1141	const Crc32Xfer = catalog.Crc32Xfer;
	1142
	1143	try testing.expectEqual(@as(u32, 0xbd0be338), Crc32Xfer.hash("123456789"));
	1144
	1145	var c = Crc32Xfer.init();
	1146	c.update("1234");
	1147	c.update("56789");
	1148	try testing.expectEqual(@as(u32, 0xbd0be338), c.final());
	1149	}
	1150
	1151	test "CRC-40/GSM" {
	1152	const Crc40Gsm = catalog.Crc40Gsm;
	1153
	1154	try testing.expectEqual(@as(u40, 0xd4164fc646), Crc40Gsm.hash("123456789"));
	1155
	1156	var c = Crc40Gsm.init();
	1157	c.update("1234");
	1158	c.update("56789");
	1159	try testing.expectEqual(@as(u40, 0xd4164fc646), c.final());
	1160	}
	1161
	1162	test "CRC-64/ECMA-182" {
	1163	const Crc64Ecma182 = catalog.Crc64Ecma182;
	1164
	1165	try testing.expectEqual(@as(u64, 0x6c40df5f0b497347), Crc64Ecma182.hash("123456789"));
	1166
	1167	var c = Crc64Ecma182.init();
	1168	c.update("1234");
	1169	c.update("56789");
	1170	try testing.expectEqual(@as(u64, 0x6c40df5f0b497347), c.final());
	1171	}
	1172
	1173	test "CRC-64/GO-ISO" {
	1174	const Crc64GoIso = catalog.Crc64GoIso;
	1175
	1176	try testing.expectEqual(@as(u64, 0xb90956c775a41001), Crc64GoIso.hash("123456789"));
	1177
	1178	var c = Crc64GoIso.init();
	1179	c.update("1234");
	1180	c.update("56789");
	1181	try testing.expectEqual(@as(u64, 0xb90956c775a41001), c.final());
	1182	}
	1183
	1184	test "CRC-64/MS" {
	1185	const Crc64Ms = catalog.Crc64Ms;
	1186
	1187	try testing.expectEqual(@as(u64, 0x75d4b74f024eceea), Crc64Ms.hash("123456789"));
	1188
	1189	var c = Crc64Ms.init();
	1190	c.update("1234");
	1191	c.update("56789");
	1192	try testing.expectEqual(@as(u64, 0x75d4b74f024eceea), c.final());
	1193	}
	1194
	1195	test "CRC-64/REDIS" {
	1196	const Crc64Redis = catalog.Crc64Redis;
	1197
	1198	try testing.expectEqual(@as(u64, 0xe9c6d914c4b8d9ca), Crc64Redis.hash("123456789"));
	1199
	1200	var c = Crc64Redis.init();
	1201	c.update("1234");
	1202	c.update("56789");
	1203	try testing.expectEqual(@as(u64, 0xe9c6d914c4b8d9ca), c.final());
	1204	}
	1205
	1206	test "CRC-64/WE" {
	1207	const Crc64We = catalog.Crc64We;
	1208
	1209	try testing.expectEqual(@as(u64, 0x62ec59e3f1a4f00a), Crc64We.hash("123456789"));
	1210
	1211	var c = Crc64We.init();
	1212	c.update("1234");
	1213	c.update("56789");
	1214	try testing.expectEqual(@as(u64, 0x62ec59e3f1a4f00a), c.final());
	1215	}
	1216
	1217	test "CRC-64/XZ" {
	1218	const Crc64Xz = catalog.Crc64Xz;
	1219
	1220	try testing.expectEqual(@as(u64, 0x995dc9bbdf1939fa), Crc64Xz.hash("123456789"));
	1221
	1222	var c = Crc64Xz.init();
	1223	c.update("1234");
	1224	c.update("56789");
	1225	try testing.expectEqual(@as(u64, 0x995dc9bbdf1939fa), c.final());
	1226	}
	1227
	1228	test "CRC-82/DARC" {
	1229	const Crc82Darc = catalog.Crc82Darc;
	1230
	1231	try testing.expectEqual(@as(u82, 0x09ea83f625023801fd612), Crc82Darc.hash("123456789"));
	1232
	1233	var c = Crc82Darc.init();
	1234	c.update("1234");
	1235	c.update("56789");
	1236	try testing.expectEqual(@as(u82, 0x09ea83f625023801fd612), c.final());
	1237	}

tools/crc/catalog.txt created+113

...	...	@@ -0,0 +1,113 @@
	1	# https://reveng.sourceforge.io/crc-catalogue/all.htm
	2	width=3 poly=0x3 init=0x0 refin=false refout=false xorout=0x7 check=0x4 residue=0x2 name="CRC-3/GSM"
	3	width=3 poly=0x3 init=0x7 refin=true refout=true xorout=0x0 check=0x6 residue=0x0 name="CRC-3/ROHC"
	4	width=4 poly=0x3 init=0x0 refin=true refout=true xorout=0x0 check=0x7 residue=0x0 name="CRC-4/G-704"
	5	width=4 poly=0x3 init=0xf refin=false refout=false xorout=0xf check=0xb residue=0x2 name="CRC-4/INTERLAKEN"
	6	width=5 poly=0x09 init=0x09 refin=false refout=false xorout=0x00 check=0x00 residue=0x00 name="CRC-5/EPC-C1G2"
	7	width=5 poly=0x15 init=0x00 refin=true refout=true xorout=0x00 check=0x07 residue=0x00 name="CRC-5/G-704"
	8	width=5 poly=0x05 init=0x1f refin=true refout=true xorout=0x1f check=0x19 residue=0x06 name="CRC-5/USB"
	9	width=6 poly=0x27 init=0x3f refin=false refout=false xorout=0x00 check=0x0d residue=0x00 name="CRC-6/CDMA2000-A"
	10	width=6 poly=0x07 init=0x3f refin=false refout=false xorout=0x00 check=0x3b residue=0x00 name="CRC-6/CDMA2000-B"
	11	width=6 poly=0x19 init=0x00 refin=true refout=true xorout=0x00 check=0x26 residue=0x00 name="CRC-6/DARC"
	12	width=6 poly=0x03 init=0x00 refin=true refout=true xorout=0x00 check=0x06 residue=0x00 name="CRC-6/G-704"
	13	width=6 poly=0x2f init=0x00 refin=false refout=false xorout=0x3f check=0x13 residue=0x3a name="CRC-6/GSM"
	14	width=7 poly=0x09 init=0x00 refin=false refout=false xorout=0x00 check=0x75 residue=0x00 name="CRC-7/MMC"
	15	width=7 poly=0x4f init=0x7f refin=true refout=true xorout=0x00 check=0x53 residue=0x00 name="CRC-7/ROHC"
	16	width=7 poly=0x45 init=0x00 refin=false refout=false xorout=0x00 check=0x61 residue=0x00 name="CRC-7/UMTS"
	17	width=8 poly=0x2f init=0xff refin=false refout=false xorout=0xff check=0xdf residue=0x42 name="CRC-8/AUTOSAR"
	18	width=8 poly=0xa7 init=0x00 refin=true refout=true xorout=0x00 check=0x26 residue=0x00 name="CRC-8/BLUETOOTH"
	19	width=8 poly=0x9b init=0xff refin=false refout=false xorout=0x00 check=0xda residue=0x00 name="CRC-8/CDMA2000"
	20	width=8 poly=0x39 init=0x00 refin=true refout=true xorout=0x00 check=0x15 residue=0x00 name="CRC-8/DARC"
	21	width=8 poly=0xd5 init=0x00 refin=false refout=false xorout=0x00 check=0xbc residue=0x00 name="CRC-8/DVB-S2"
	22	width=8 poly=0x1d init=0x00 refin=false refout=false xorout=0x00 check=0x37 residue=0x00 name="CRC-8/GSM-A"
	23	width=8 poly=0x49 init=0x00 refin=false refout=false xorout=0xff check=0x94 residue=0x53 name="CRC-8/GSM-B"
	24	width=8 poly=0x1d init=0xff refin=false refout=false xorout=0x00 check=0xb4 residue=0x00 name="CRC-8/HITAG"
	25	width=8 poly=0x07 init=0x00 refin=false refout=false xorout=0x55 check=0xa1 residue=0xac name="CRC-8/I-432-1"
	26	width=8 poly=0x1d init=0xfd refin=false refout=false xorout=0x00 check=0x7e residue=0x00 name="CRC-8/I-CODE"
	27	width=8 poly=0x9b init=0x00 refin=false refout=false xorout=0x00 check=0xea residue=0x00 name="CRC-8/LTE"
	28	width=8 poly=0x31 init=0x00 refin=true refout=true xorout=0x00 check=0xa1 residue=0x00 name="CRC-8/MAXIM-DOW"
	29	width=8 poly=0x1d init=0xc7 refin=false refout=false xorout=0x00 check=0x99 residue=0x00 name="CRC-8/MIFARE-MAD"
	30	width=8 poly=0x31 init=0xff refin=false refout=false xorout=0x00 check=0xf7 residue=0x00 name="CRC-8/NRSC-5"
	31	width=8 poly=0x2f init=0x00 refin=false refout=false xorout=0x00 check=0x3e residue=0x00 name="CRC-8/OPENSAFETY"
	32	width=8 poly=0x07 init=0xff refin=true refout=true xorout=0x00 check=0xd0 residue=0x00 name="CRC-8/ROHC"
	33	width=8 poly=0x1d init=0xff refin=false refout=false xorout=0xff check=0x4b residue=0xc4 name="CRC-8/SAE-J1850"
	34	width=8 poly=0x07 init=0x00 refin=false refout=false xorout=0x00 check=0xf4 residue=0x00 name="CRC-8/SMBUS"
	35	width=8 poly=0x1d init=0xff refin=true refout=true xorout=0x00 check=0x97 residue=0x00 name="CRC-8/TECH-3250"
	36	width=8 poly=0x9b init=0x00 refin=true refout=true xorout=0x00 check=0x25 residue=0x00 name="CRC-8/WCDMA"
	37	width=10 poly=0x233 init=0x000 refin=false refout=false xorout=0x000 check=0x199 residue=0x000 name="CRC-10/ATM"
	38	width=10 poly=0x3d9 init=0x3ff refin=false refout=false xorout=0x000 check=0x233 residue=0x000 name="CRC-10/CDMA2000"
	39	width=10 poly=0x175 init=0x000 refin=false refout=false xorout=0x3ff check=0x12a residue=0x0c6 name="CRC-10/GSM"
	40	width=11 poly=0x385 init=0x01a refin=false refout=false xorout=0x000 check=0x5a3 residue=0x000 name="CRC-11/FLEXRAY"
	41	width=11 poly=0x307 init=0x000 refin=false refout=false xorout=0x000 check=0x061 residue=0x000 name="CRC-11/UMTS"
	42	width=12 poly=0xf13 init=0xfff refin=false refout=false xorout=0x000 check=0xd4d residue=0x000 name="CRC-12/CDMA2000"
	43	width=12 poly=0x80f init=0x000 refin=false refout=false xorout=0x000 check=0xf5b residue=0x000 name="CRC-12/DECT"
	44	width=12 poly=0xd31 init=0x000 refin=false refout=false xorout=0xfff check=0xb34 residue=0x178 name="CRC-12/GSM"
	45	width=12 poly=0x80f init=0x000 refin=false refout=true xorout=0x000 check=0xdaf residue=0x000 name="CRC-12/UMTS"
	46	width=13 poly=0x1cf5 init=0x0000 refin=false refout=false xorout=0x0000 check=0x04fa residue=0x0000 name="CRC-13/BBC"
	47	width=14 poly=0x0805 init=0x0000 refin=true refout=true xorout=0x0000 check=0x082d residue=0x0000 name="CRC-14/DARC"
	48	width=14 poly=0x202d init=0x0000 refin=false refout=false xorout=0x3fff check=0x30ae residue=0x031e name="CRC-14/GSM"
	49	width=15 poly=0x4599 init=0x0000 refin=false refout=false xorout=0x0000 check=0x059e residue=0x0000 name="CRC-15/CAN"
	50	width=15 poly=0x6815 init=0x0000 refin=false refout=false xorout=0x0001 check=0x2566 residue=0x6815 name="CRC-15/MPT1327"
	51	width=16 poly=0x8005 init=0x0000 refin=true refout=true xorout=0x0000 check=0xbb3d residue=0x0000 name="CRC-16/ARC"
	52	width=16 poly=0xc867 init=0xffff refin=false refout=false xorout=0x0000 check=0x4c06 residue=0x0000 name="CRC-16/CDMA2000"
	53	width=16 poly=0x8005 init=0xffff refin=false refout=false xorout=0x0000 check=0xaee7 residue=0x0000 name="CRC-16/CMS"
	54	width=16 poly=0x8005 init=0x800d refin=false refout=false xorout=0x0000 check=0x9ecf residue=0x0000 name="CRC-16/DDS-110"
	55	width=16 poly=0x0589 init=0x0000 refin=false refout=false xorout=0x0001 check=0x007e residue=0x0589 name="CRC-16/DECT-R"
	56	width=16 poly=0x0589 init=0x0000 refin=false refout=false xorout=0x0000 check=0x007f residue=0x0000 name="CRC-16/DECT-X"
	57	width=16 poly=0x3d65 init=0x0000 refin=true refout=true xorout=0xffff check=0xea82 residue=0x66c5 name="CRC-16/DNP"
	58	width=16 poly=0x3d65 init=0x0000 refin=false refout=false xorout=0xffff check=0xc2b7 residue=0xa366 name="CRC-16/EN-13757"
	59	width=16 poly=0x1021 init=0xffff refin=false refout=false xorout=0xffff check=0xd64e residue=0x1d0f name="CRC-16/GENIBUS"
	60	width=16 poly=0x1021 init=0x0000 refin=false refout=false xorout=0xffff check=0xce3c residue=0x1d0f name="CRC-16/GSM"
	61	width=16 poly=0x1021 init=0xffff refin=false refout=false xorout=0x0000 check=0x29b1 residue=0x0000 name="CRC-16/IBM-3740"
	62	width=16 poly=0x1021 init=0xffff refin=true refout=true xorout=0xffff check=0x906e residue=0xf0b8 name="CRC-16/IBM-SDLC"
	63	width=16 poly=0x1021 init=0xc6c6 refin=true refout=true xorout=0x0000 check=0xbf05 residue=0x0000 name="CRC-16/ISO-IEC-14443-3-A"
	64	width=16 poly=0x1021 init=0x0000 refin=true refout=true xorout=0x0000 check=0x2189 residue=0x0000 name="CRC-16/KERMIT"
	65	width=16 poly=0x6f63 init=0x0000 refin=false refout=false xorout=0x0000 check=0xbdf4 residue=0x0000 name="CRC-16/LJ1200"
	66	width=16 poly=0x5935 init=0xffff refin=false refout=false xorout=0x0000 check=0x772b residue=0x0000 name="CRC-16/M17"
	67	width=16 poly=0x8005 init=0x0000 refin=true refout=true xorout=0xffff check=0x44c2 residue=0xb001 name="CRC-16/MAXIM-DOW"
	68	width=16 poly=0x1021 init=0xffff refin=true refout=true xorout=0x0000 check=0x6f91 residue=0x0000 name="CRC-16/MCRF4XX"
	69	width=16 poly=0x8005 init=0xffff refin=true refout=true xorout=0x0000 check=0x4b37 residue=0x0000 name="CRC-16/MODBUS"
	70	width=16 poly=0x080b init=0xffff refin=true refout=true xorout=0x0000 check=0xa066 residue=0x0000 name="CRC-16/NRSC-5"
	71	width=16 poly=0x5935 init=0x0000 refin=false refout=false xorout=0x0000 check=0x5d38 residue=0x0000 name="CRC-16/OPENSAFETY-A"
	72	width=16 poly=0x755b init=0x0000 refin=false refout=false xorout=0x0000 check=0x20fe residue=0x0000 name="CRC-16/OPENSAFETY-B"
	73	width=16 poly=0x1dcf init=0xffff refin=false refout=false xorout=0xffff check=0xa819 residue=0xe394 name="CRC-16/PROFIBUS"
	74	width=16 poly=0x1021 init=0xb2aa refin=true refout=true xorout=0x0000 check=0x63d0 residue=0x0000 name="CRC-16/RIELLO"
	75	width=16 poly=0x1021 init=0x1d0f refin=false refout=false xorout=0x0000 check=0xe5cc residue=0x0000 name="CRC-16/SPI-FUJITSU"
	76	width=16 poly=0x8bb7 init=0x0000 refin=false refout=false xorout=0x0000 check=0xd0db residue=0x0000 name="CRC-16/T10-DIF"
	77	width=16 poly=0xa097 init=0x0000 refin=false refout=false xorout=0x0000 check=0x0fb3 residue=0x0000 name="CRC-16/TELEDISK"
	78	width=16 poly=0x1021 init=0x89ec refin=true refout=true xorout=0x0000 check=0x26b1 residue=0x0000 name="CRC-16/TMS37157"
	79	width=16 poly=0x8005 init=0x0000 refin=false refout=false xorout=0x0000 check=0xfee8 residue=0x0000 name="CRC-16/UMTS"
	80	width=16 poly=0x8005 init=0xffff refin=true refout=true xorout=0xffff check=0xb4c8 residue=0xb001 name="CRC-16/USB"
	81	width=16 poly=0x1021 init=0x0000 refin=false refout=false xorout=0x0000 check=0x31c3 residue=0x0000 name="CRC-16/XMODEM"
	82	width=17 poly=0x1685b init=0x00000 refin=false refout=false xorout=0x00000 check=0x04f03 residue=0x00000 name="CRC-17/CAN-FD"
	83	width=21 poly=0x102899 init=0x000000 refin=false refout=false xorout=0x000000 check=0x0ed841 residue=0x000000 name="CRC-21/CAN-FD"
	84	width=24 poly=0x00065b init=0x555555 refin=true refout=true xorout=0x000000 check=0xc25a56 residue=0x000000 name="CRC-24/BLE"
	85	width=24 poly=0x5d6dcb init=0xfedcba refin=false refout=false xorout=0x000000 check=0x7979bd residue=0x000000 name="CRC-24/FLEXRAY-A"
	86	width=24 poly=0x5d6dcb init=0xabcdef refin=false refout=false xorout=0x000000 check=0x1f23b8 residue=0x000000 name="CRC-24/FLEXRAY-B"
	87	width=24 poly=0x328b63 init=0xffffff refin=false refout=false xorout=0xffffff check=0xb4f3e6 residue=0x144e63 name="CRC-24/INTERLAKEN"
	88	width=24 poly=0x864cfb init=0x000000 refin=false refout=false xorout=0x000000 check=0xcde703 residue=0x000000 name="CRC-24/LTE-A"
	89	width=24 poly=0x800063 init=0x000000 refin=false refout=false xorout=0x000000 check=0x23ef52 residue=0x000000 name="CRC-24/LTE-B"
	90	width=24 poly=0x864cfb init=0xb704ce refin=false refout=false xorout=0x000000 check=0x21cf02 residue=0x000000 name="CRC-24/OPENPGP"
	91	width=24 poly=0x800063 init=0xffffff refin=false refout=false xorout=0xffffff check=0x200fa5 residue=0x800fe3 name="CRC-24/OS-9"
	92	width=30 poly=0x2030b9c7 init=0x3fffffff refin=false refout=false xorout=0x3fffffff check=0x04c34abf residue=0x34efa55a name="CRC-30/CDMA"
	93	width=31 poly=0x04c11db7 init=0x7fffffff refin=false refout=false xorout=0x7fffffff check=0x0ce9e46c residue=0x4eaf26f1 name="CRC-31/PHILIPS"
	94	width=32 poly=0x814141ab init=0x00000000 refin=false refout=false xorout=0x00000000 check=0x3010bf7f residue=0x00000000 name="CRC-32/AIXM"
	95	width=32 poly=0xf4acfb13 init=0xffffffff refin=true refout=true xorout=0xffffffff check=0x1697d06a residue=0x904cddbf name="CRC-32/AUTOSAR"
	96	width=32 poly=0xa833982b init=0xffffffff refin=true refout=true xorout=0xffffffff check=0x87315576 residue=0x45270551 name="CRC-32/BASE91-D"
	97	width=32 poly=0x04c11db7 init=0xffffffff refin=false refout=false xorout=0xffffffff check=0xfc891918 residue=0xc704dd7b name="CRC-32/BZIP2"
	98	width=32 poly=0x8001801b init=0x00000000 refin=true refout=true xorout=0x00000000 check=0x6ec2edc4 residue=0x00000000 name="CRC-32/CD-ROM-EDC"
	99	width=32 poly=0x04c11db7 init=0x00000000 refin=false refout=false xorout=0xffffffff check=0x765e7680 residue=0xc704dd7b name="CRC-32/CKSUM"
	100	width=32 poly=0x1edc6f41 init=0xffffffff refin=true refout=true xorout=0xffffffff check=0xe3069283 residue=0xb798b438 name="CRC-32/ISCSI"
	101	width=32 poly=0x04c11db7 init=0xffffffff refin=true refout=true xorout=0xffffffff check=0xcbf43926 residue=0xdebb20e3 name="CRC-32/ISO-HDLC"
	102	width=32 poly=0x04c11db7 init=0xffffffff refin=true refout=true xorout=0x00000000 check=0x340bc6d9 residue=0x00000000 name="CRC-32/JAMCRC"
	103	width=32 poly=0x741b8cd7 init=0xffffffff refin=true refout=true xorout=0x00000000 check=0xd2c22f51 residue=0x00000000 name="CRC-32/MEF"
	104	width=32 poly=0x04c11db7 init=0xffffffff refin=false refout=false xorout=0x00000000 check=0x0376e6e7 residue=0x00000000 name="CRC-32/MPEG-2"
	105	width=32 poly=0x000000af init=0x00000000 refin=false refout=false xorout=0x00000000 check=0xbd0be338 residue=0x00000000 name="CRC-32/XFER"
	106	width=40 poly=0x0004820009 init=0x0000000000 refin=false refout=false xorout=0xffffffffff check=0xd4164fc646 residue=0xc4ff8071ff name="CRC-40/GSM"
	107	width=64 poly=0x42f0e1eba9ea3693 init=0x0000000000000000 refin=false refout=false xorout=0x0000000000000000 check=0x6c40df5f0b497347 residue=0x0000000000000000 name="CRC-64/ECMA-182"
	108	width=64 poly=0x000000000000001b init=0xffffffffffffffff refin=true refout=true xorout=0xffffffffffffffff check=0xb90956c775a41001 residue=0x5300000000000000 name="CRC-64/GO-ISO"
	109	width=64 poly=0x259c84cba6426349 init=0xffffffffffffffff refin=true refout=true xorout=0x0000000000000000 check=0x75d4b74f024eceea residue=0x0000000000000000 name="CRC-64/MS"
	110	width=64 poly=0xad93d23594c935a9 init=0x0000000000000000 refin=true refout=true xorout=0x0000000000000000 check=0xe9c6d914c4b8d9ca residue=0x0000000000000000 name="CRC-64/REDIS"
	111	width=64 poly=0x42f0e1eba9ea3693 init=0xffffffffffffffff refin=false refout=false xorout=0xffffffffffffffff check=0x62ec59e3f1a4f00a residue=0xfcacbebd5931a992 name="CRC-64/WE"
	112	width=64 poly=0x42f0e1eba9ea3693 init=0xffffffffffffffff refin=true refout=true xorout=0xffffffffffffffff check=0x995dc9bbdf1939fa residue=0x49958c9abd7d353f name="CRC-64/XZ"
	113	width=82 poly=0x0308c0111011401440411 init=0x000000000000000000000 refin=true refout=true xorout=0x000000000000000000000 check=0x09ea83f625023801fd612 residue=0x000000000000000000000 name="CRC-82/DARC"

tools/update_crc_catalog.sh deleted-40

...	...	@@ -1,40 +0,0 @@
1		if [ $# -lt 1 ]; then
2		echo "Usage: $0 /path/git/zig"
3		exit 1
4		fi
5
6		filepath=$1/lib/std/hash/crc/catalog.zig
7
8		cat <<EOS >$filepath
9		//! This file is auto-generated by tools/update_crc_catalog.sh.
10
11		const std = @import("../../std.zig");
12		const testing = std.testing;
13		const crc = @import("../crc.zig");
14		const Algorithm = crc.Algorithm;
15		const Crc = crc.Crc;
16		EOS
17
18		curl -s https://reveng.sourceforge.io/crc-catalogue/all.htm \| grep -o 'width.name."' \| while read -r line; do
19		width=$(echo $line \| sed 's/width=$[0-9]$ $.$ name="$.*$"/\1/')
20		params=$(echo $line \| sed 's/width=$[0-9]$ $.$ name="$.*$"/\2/' \| sed 's/ /, ./g' \| sed 's/=/ = /g')
21		name=$(echo $line \| sed 's/width=$[0-9]$ $.$ name="$.*$"/\3/')
22		snakecase=$(echo $name \| sed 's/[-\/]/_/g' \| tr '[:upper:]' '[:lower:]')
23		camelcase=$(echo $snakecase \| perl -pe 's/(^\|_)(\w)/\U$2/g')
24
25		cat <<EOS >>$filepath
26
27		const $snakecase: Algorithm(u$width) = .{ .$params };
28
29		pub const $camelcase = Crc(u$width, $snakecase);
30
31		test "$name" {
32		try testing.expectEqual($snakecase.check, $camelcase.hash("123456789"));
33
34		var c = $camelcase.init();
35		c.update("1234");
36		c.update("56789");
37		try testing.expectEqual($snakecase.check, c.final());
38		}
39		EOS
40		done

tools/update_crc_catalog.zig created+169

...	...	@@ -0,0 +1,169 @@
	1	const std = @import("std");
	2	const fs = std.fs;
	3	const mem = std.mem;
	4	const ascii = std.ascii;
	5
	6	const catalog_txt = @embedFile("crc/catalog.txt");
	7
	8	pub fn main() anyerror!void {
	9	var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
	10	defer arena_state.deinit();
	11	const arena = arena_state.allocator();
	12
	13	const args = try std.process.argsAlloc(arena);
	14	if (args.len <= 1) {
	15	usageAndExit(std.io.getStdErr(), args[0], 1);
	16	}
	17
	18	const zig_src_root = args[1];
	19	if (mem.startsWith(u8, zig_src_root, "-")) {
	20	usageAndExit(std.io.getStdErr(), args[0], 1);
	21	}
	22
	23	var zig_src_dir = try fs.cwd().openDir(zig_src_root, .{});
	24	defer zig_src_dir.close();
	25
	26	const target_sub_path = try fs.path.join(arena, &.{ "lib", "std", "hash", "crc" });
	27	var target_dir = try zig_src_dir.makeOpenPath(target_sub_path, .{});
	28	defer target_dir.close();
	29
	30	var zig_code_file = try target_dir.createFile("catalog.zig", .{});
	31	defer zig_code_file.close();
	32
	33	var cbw = std.io.bufferedWriter(zig_code_file.writer());
	34	defer cbw.flush() catch unreachable;
	35	const code_writer = cbw.writer();
	36
	37	try code_writer.writeAll(
	38	\\//! This file is auto-generated by tools/update_crc_catalog.zig.
	39	\\
	40	\\const Crc = @import("../crc.zig").Crc;
	41	\\
	42	\\test {
	43	\\ _ = @import("catalog_test.zig");
	44	\\}
	45	\\
	46	);
	47
	48	var zig_test_file = try target_dir.createFile("catalog_test.zig", .{});
	49	defer zig_test_file.close();
	50
	51	var tbw = std.io.bufferedWriter(zig_test_file.writer());
	52	defer tbw.flush() catch unreachable;
	53	const test_writer = tbw.writer();
	54
	55	try test_writer.writeAll(
	56	\\//! This file is auto-generated by tools/update_crc_catalog.zig.
	57	\\
	58	\\const std = @import("../../std.zig");
	59	\\const testing = std.testing;
	60	\\const catalog = @import("catalog.zig");
	61	\\
	62	);
	63
	64	var stream = std.io.fixedBufferStream(catalog_txt);
	65	const reader = stream.reader();
	66
	67	while (try reader.readUntilDelimiterOrEofAlloc(arena, '\n', std.math.maxInt(usize))) \|line\| {
	68	if (line.len == 0 or line[0] == '#')
	69	continue;
	70
	71	var width: []const u8 = undefined;
	72	var poly: []const u8 = undefined;
	73	var init: []const u8 = undefined;
	74	var refin: []const u8 = undefined;
	75	var refout: []const u8 = undefined;
	76	var xorout: []const u8 = undefined;
	77	var check: []const u8 = undefined;
	78	var residue: []const u8 = undefined;
	79	var name: []const u8 = undefined;
	80
	81	var it = mem.split(u8, line, " ");
	82	while (it.next()) \|property\| {
	83	const i = mem.indexOf(u8, property, "=").?;
	84	const key = property[0..i];
	85	const value = property[i + 1 ..];
	86	if (mem.eql(u8, key, "width")) {
	87	width = value;
	88	} else if (mem.eql(u8, key, "poly")) {
	89	poly = value;
	90	} else if (mem.eql(u8, key, "init")) {
	91	init = value;
	92	} else if (mem.eql(u8, key, "refin")) {
	93	refin = value;
	94	} else if (mem.eql(u8, key, "refout")) {
	95	refout = value;
	96	} else if (mem.eql(u8, key, "xorout")) {
	97	xorout = value;
	98	} else if (mem.eql(u8, key, "check")) {
	99	check = value;
	100	} else if (mem.eql(u8, key, "residue")) {
	101	residue = value;
	102	} else if (mem.eql(u8, key, "name")) {
	103	name = mem.trim(u8, value, "\"");
	104	} else {
	105	unreachable;
	106	}
	107	}
	108
	109	const snakecase = try ascii.allocLowerString(arena, name);
	110	defer arena.free(snakecase);
	111
	112	_ = mem.replace(u8, snakecase, "-", "_", snakecase);
	113	_ = mem.replace(u8, snakecase, "/", "_", snakecase);
	114
	115	var buf = try std.ArrayList(u8).initCapacity(arena, snakecase.len);
	116	defer buf.deinit();
	117
	118	var prev: u8 = 0;
	119	for (snakecase) \|c, i\| {
	120	if (c == '_') {
	121	// do nothing
	122	} else if (i == 0) {
	123	buf.appendAssumeCapacity(ascii.toUpper(c));
	124	} else if (prev == '_') {
	125	buf.appendAssumeCapacity(ascii.toUpper(c));
	126	} else {
	127	buf.appendAssumeCapacity(c);
	128	}
	129	prev = c;
	130	}
	131
	132	const camelcase = buf.items;
	133
	134	try code_writer.writeAll(try std.fmt.allocPrint(arena,
	135	\\
	136	\\pub const {s} = Crc(u{s}, .{{
	137	\\ .polynomial = {s},
	138	\\ .initial = {s},
	139	\\ .reflect_input = {s},
	140	\\ .reflect_output = {s},
	141	\\ .xor_output = {s},
	142	\\}});
	143	\\
	144	, .{ camelcase, width, poly, init, refin, refout, xorout }));
	145
	146	try test_writer.writeAll(try std.fmt.allocPrint(arena,
	147	\\
	148	\\test "{0s}" {{
	149	\\ const {1s} = catalog.{1s};
	150	\\
	151	\\ try testing.expectEqual(@as(u{2s}, {3s}), {1s}.hash("123456789"));
	152	\\
	153	\\ var c = {1s}.init();
	154	\\ c.update("1234");
	155	\\ c.update("56789");
	156	\\ try testing.expectEqual(@as(u{2s}, {3s}), c.final());
	157	\\}}
	158	\\
	159	, .{ name, camelcase, width, check }));
	160	}
	161	}
	162
	163	fn usageAndExit(file: fs.File, arg0: []const u8, code: u8) noreturn {
	164	file.writer().print(
	165	\\Usage: {s} /path/git/zig
	166	\\
	167	, .{arg0}) catch std.process.exit(1);
	168	std.process.exit(code);
	169	}