ipaddress 0.2.6 → 0.2.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (57) hide show
  1. package/dist/src/crunchy.d.ts +107 -33
  2. package/dist/src/crunchy.d.ts.map +1 -1
  3. package/dist/src/crunchy.js +274 -142
  4. package/dist/src/ip_bits.d.ts +2 -2
  5. package/dist/src/ip_bits.d.ts.map +1 -1
  6. package/dist/src/ipaddress.d.ts +24 -23
  7. package/dist/src/ipaddress.d.ts.map +1 -1
  8. package/dist/src/ipaddress.js +22 -7
  9. package/dist/src/ipv4.d.ts +3 -3
  10. package/dist/src/ipv4.d.ts.map +1 -1
  11. package/dist/src/ipv4.js +26 -15
  12. package/dist/src/ipv6.d.ts +4 -4
  13. package/dist/src/ipv6.d.ts.map +1 -1
  14. package/dist/src/ipv6.js +1 -1
  15. package/dist/src/ipv6_loopback.d.ts +1 -1
  16. package/dist/src/ipv6_loopback.d.ts.map +1 -1
  17. package/dist/src/ipv6_mapped.d.ts +1 -1
  18. package/dist/src/ipv6_mapped.d.ts.map +1 -1
  19. package/dist/src/ipv6_unspec.d.ts +1 -1
  20. package/dist/src/ipv6_unspec.d.ts.map +1 -1
  21. package/dist/src/prefix128.d.ts +1 -1
  22. package/dist/src/prefix128.d.ts.map +1 -1
  23. package/dist/src/prefix128.js +5 -1
  24. package/dist/src/prefix32.d.ts +1 -1
  25. package/dist/src/prefix32.d.ts.map +1 -1
  26. package/dist/src/prefix32.js +5 -1
  27. package/dist/test/test_crunchy_impls.d.ts +2 -0
  28. package/dist/test/test_crunchy_impls.d.ts.map +1 -0
  29. package/dist/test/test_crunchy_impls.js +150 -0
  30. package/dist/test/test_crunchy_with32bit.d.ts +2 -0
  31. package/dist/test/test_crunchy_with32bit.d.ts.map +1 -0
  32. package/dist/test/{test_crunchy.js → test_crunchy_with32bit.js} +113 -182
  33. package/dist/test/test_ipv4.js +1 -1
  34. package/dist/test/test_ipv6.js +1 -1
  35. package/package.json +10 -9
  36. package/src/crunchy.ts +365 -180
  37. package/src/ip_bits.ts +11 -11
  38. package/src/ipaddress.ts +49 -33
  39. package/src/ipv4.ts +32 -19
  40. package/src/ipv6.ts +6 -6
  41. package/src/ipv6_loopback.ts +1 -1
  42. package/src/ipv6_mapped.ts +1 -1
  43. package/src/ipv6_unspec.ts +1 -1
  44. package/src/prefix128.ts +6 -2
  45. package/src/prefix32.ts +6 -2
  46. package/test/test_crunchy_impls.ts +179 -0
  47. package/test/{test_crunchy.ts → test_crunchy_with32bit.ts} +131 -235
  48. package/test/test_ipaddress.ts +9 -9
  49. package/test/test_ipv4.ts +115 -115
  50. package/test/test_ipv6.ts +62 -62
  51. package/test/test_ipv6_loopback.ts +1 -1
  52. package/test/test_ipv6_mapped.ts +4 -4
  53. package/test/test_ipv6_unspec.ts +1 -1
  54. package/test/test_prefix128.ts +2 -2
  55. package/test/test_prefix32.ts +13 -13
  56. package/dist/test/test_crunchy.d.ts +0 -2
  57. package/dist/test/test_crunchy.d.ts.map +0 -1
@@ -12,8 +12,8 @@ class IPAddressTest {
12
12
  }
13
13
 
14
14
  class RangeItem {
15
- start: number;
16
- target: number;
15
+ start!: number;
16
+ target!: number;
17
17
  }
18
18
  function Range(start: number, target: number) {
19
19
  const ri = new RangeItem();
@@ -39,9 +39,9 @@ describe("IPAddressTest", () => {
39
39
  assert.isOk(IPAddress.parse(setup().valid_ipv6));
40
40
  assert.isOk(IPAddress.parse(setup().valid_mapped));
41
41
 
42
- assert.isOk(IPAddress.parse(setup().valid_ipv4).is_ipv4());
43
- assert.isOk(IPAddress.parse(setup().valid_ipv6).is_ipv6());
44
- assert.isOk(IPAddress.parse(setup().valid_mapped).is_mapped());
42
+ assert.isOk(IPAddress.parse(setup().valid_ipv4)!.is_ipv4());
43
+ assert.isOk(IPAddress.parse(setup().valid_ipv6)!.is_ipv6());
44
+ assert.isOk(IPAddress.parse(setup().valid_mapped)!.is_mapped());
45
45
 
46
46
  assert.isNull(IPAddress.parse(setup().invalid_ipv4));
47
47
  assert.isNull(IPAddress.parse(setup().invalid_ipv6));
@@ -91,7 +91,7 @@ describe("IPAddressTest", () => {
91
91
  }
92
92
  const ip_addresses: IPAddress[] = [];
93
93
  for (const net of netstr) {
94
- ip_addresses.push(IPAddress.parse(net));
94
+ ip_addresses.push(IPAddress.parse(net)!);
95
95
  }
96
96
 
97
97
  const empty_vec: string[] = [];
@@ -201,8 +201,8 @@ describe("IPAddressTest", () => {
201
201
  // test imutable input parameters
202
202
  const a1 = IPAddress.parse("10.0.0.1/24");
203
203
  const a2 = IPAddress.parse("10.0.1.1/24");
204
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([a1.clone(), a2.clone()])), ["10.0.0.0/23"]);
205
- assert.equal("10.0.0.1/24", a1.to_string());
206
- assert.equal("10.0.1.1/24", a2.to_string());
204
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([a1!.clone(), a2!.clone()])), ["10.0.0.0/23"]);
205
+ assert.equal("10.0.0.1/24", a1!.to_string());
206
+ assert.equal("10.0.1.1/24", a2!.to_string());
207
207
  }, 15000);
208
208
  });
package/test/test_ipv4.ts CHANGED
@@ -23,13 +23,13 @@ class IPv4Test {
23
23
  valid_ipv4_range: string[] = ["10.0.0.1-254", "10.0.1-254.0", "10.1-254.0.0"];
24
24
  netmask_values: [string, string][] = [];
25
25
  decimal_values: [string, Crunchy][] = [];
26
- ip: IPAddress = IPAddress.parse("172.16.10.1/24");
27
- network: IPAddress = IPAddress.parse("172.16.10.0/24");
26
+ ip: IPAddress = IPAddress.parse("172.16.10.1/24")!;
27
+ network: IPAddress = IPAddress.parse("172.16.10.0/24")!;
28
28
  networks: [string, string][] = [];
29
29
  broadcast: [string, string][] = [];
30
- class_a: IPAddress = IPAddress.parse("10.0.0.1/8");
31
- class_b: IPAddress = IPAddress.parse("172.16.0.1/16");
32
- class_c: IPAddress = IPAddress.parse("192.168.0.1/24");
30
+ class_a: IPAddress = IPAddress.parse("10.0.0.1/8")!;
31
+ class_b: IPAddress = IPAddress.parse("172.16.0.1/16")!;
32
+ class_c: IPAddress = IPAddress.parse("192.168.0.1/24")!;
33
33
  classful: [string, number][] = [];
34
34
  }
35
35
 
@@ -125,7 +125,7 @@ describe("Ipv4Test", () => {
125
125
  for (const i of setup().valid_ipv4) {
126
126
  // console.log(i[0]);
127
127
  const ip = IPAddress.parse(i[0]);
128
- assert.isOk(ip.is_ipv4() && !ip.is_ipv6());
128
+ assert.isOk(ip!.is_ipv4() && !ip!.is_ipv6());
129
129
  }
130
130
  assert.equal(32, setup().ip.prefix.ip_bits.bits);
131
131
  assert.isNull(IPAddress.parse("1.f.13.1/-3"));
@@ -140,8 +140,8 @@ describe("Ipv4Test", () => {
140
140
  it("test_initialize_without_prefix", () => {
141
141
  assert.isOk(IPAddress.parse("10.10.0.0"));
142
142
  const ip = IPAddress.parse("10.10.0.0");
143
- assert.isOk(!ip.is_ipv6() && ip.is_ipv4());
144
- assert.equal(32, ip.prefix.num);
143
+ assert.isOk(!ip!.is_ipv6() && ip!.is_ipv4());
144
+ assert.equal(32, ip!.prefix.num);
145
145
  });
146
146
  it("test_attributes", () => {
147
147
  for (const i of setup().valid_ipv4) {
@@ -149,20 +149,20 @@ describe("Ipv4Test", () => {
149
149
  const attr = i[1];
150
150
  const ip = IPAddress.parse(arg);
151
151
  // println!("test_attributes:{}:{:?}", arg, attr);
152
- assert.equal(attr.ip, ip.to_s());
153
- assert.equal(attr.prefix, ip.prefix.num);
152
+ assert.equal(attr.ip, ip!.to_s());
153
+ assert.equal(attr.prefix, ip!.prefix.num);
154
154
  }
155
155
  });
156
156
  it("test_octets", () => {
157
157
  const ip = IPAddress.parse("10.1.2.3/8");
158
- assertArrayEqual(ip.parts(), [10, 1, 2, 3]);
158
+ assertArrayEqual(ip!.parts(), [10, 1, 2, 3]);
159
159
  });
160
160
  it("test_method_to_string", () => {
161
161
  for (const i of setup().valid_ipv4) {
162
162
  const arg = i[0];
163
163
  const attr = i[1];
164
164
  const ip = IPAddress.parse(arg);
165
- assert.equal(`${attr.ip}/${attr.prefix}`, ip.to_string());
165
+ assert.equal(`${attr.ip}/${attr.prefix}`, ip!.to_string());
166
166
  }
167
167
  });
168
168
  it("test_method_to_s", () => {
@@ -170,7 +170,7 @@ describe("Ipv4Test", () => {
170
170
  const arg = i[0];
171
171
  const attr = i[1];
172
172
  const ip = IPAddress.parse(arg);
173
- assert.equal(attr.ip, ip.to_s());
173
+ assert.equal(attr.ip, ip!.to_s());
174
174
  // let ip_c = IPAddress.parse(arg);
175
175
  // assert.equal(attr.ip, ip.to_s());
176
176
  }
@@ -180,7 +180,7 @@ describe("Ipv4Test", () => {
180
180
  const addr = i[0];
181
181
  const mask = i[1];
182
182
  const ip = IPAddress.parse(addr);
183
- assert.equal(ip.netmask().to_s(), mask);
183
+ assert.equal(ip!.netmask().to_s(), mask);
184
184
  }
185
185
  });
186
186
  it("test_method_to_u32", () => {
@@ -188,7 +188,7 @@ describe("Ipv4Test", () => {
188
188
  const addr = i[0];
189
189
  const int = i[1];
190
190
  const ip = IPAddress.parse(addr);
191
- assert.isOk(ip.host_address.eq(int));
191
+ assert.isOk(ip!.host_address.eq(int));
192
192
  }
193
193
  });
194
194
  it("test_method_is_network", () => {
@@ -197,14 +197,14 @@ describe("Ipv4Test", () => {
197
197
  });
198
198
  it("test_one_address_network", () => {
199
199
  const network = IPAddress.parse("172.16.10.1/32");
200
- assert.equal(false, network.is_network());
200
+ assert.equal(false, network!.is_network());
201
201
  });
202
202
  it("test_method_broadcast", () => {
203
203
  for (const i of setup().broadcast) {
204
204
  const addr = i[0];
205
205
  const bcast = i[1];
206
206
  const ip = IPAddress.parse(addr);
207
- assert.equal(bcast, ip.broadcast().to_string());
207
+ assert.equal(bcast, ip!.broadcast().to_string());
208
208
  }
209
209
  });
210
210
  it("test_method_network", () => {
@@ -212,40 +212,40 @@ describe("Ipv4Test", () => {
212
212
  const addr = i[0];
213
213
  const net = i[1];
214
214
  const ip = IPAddress.parse(addr);
215
- assert.equal(net, ip.network().to_string());
215
+ assert.equal(net, ip!.network().to_string());
216
216
  }
217
217
  });
218
218
  it("test_method_bits", () => {
219
219
  const ip = IPAddress.parse("127.0.0.1");
220
- assert.equal("01111111000000000000000000000001", ip.bits());
220
+ assert.equal("01111111000000000000000000000001", ip!.bits());
221
221
  });
222
222
  it("test_method_first", () => {
223
223
  let ip = IPAddress.parse("192.168.100.0/24");
224
- assert.equal("192.168.100.1", ip.first().to_s());
224
+ assert.equal("192.168.100.1", ip!.first().to_s());
225
225
  ip = IPAddress.parse("192.168.100.50/24");
226
- assert.equal("192.168.100.1", ip.first().to_s());
226
+ assert.equal("192.168.100.1", ip!.first().to_s());
227
227
  });
228
228
  it("test_method_last", () => {
229
229
  let ip = IPAddress.parse("192.168.100.0/24");
230
- assert.equal("192.168.100.254", ip.last().to_s());
230
+ assert.equal("192.168.100.254", ip!.last().to_s());
231
231
  ip = IPAddress.parse("192.168.100.50/24");
232
- assert.equal("192.168.100.254", ip.last().to_s());
232
+ assert.equal("192.168.100.254", ip!.last().to_s());
233
233
  });
234
234
  it("test_method_each_host", () => {
235
235
  const ip = IPAddress.parse("10.0.0.1/29");
236
236
  const arr: string[] = [];
237
- ip.each_host((i) => arr.push(i.to_s()));
237
+ ip!.each_host((i) => arr.push(i.to_s()));
238
238
  assertArrayEqual(arr, ["10.0.0.1", "10.0.0.2", "10.0.0.3", "10.0.0.4", "10.0.0.5", "10.0.0.6"]);
239
239
  });
240
240
  it("test_method_each", () => {
241
241
  const ip = IPAddress.parse("10.0.0.1/29");
242
242
  const arr: string[] = [];
243
- ip.each((i) => arr.push(i.to_s()));
243
+ ip!.each((i) => arr.push(i.to_s()));
244
244
  assertArrayEqual(arr, ["10.0.0.0", "10.0.0.1", "10.0.0.2", "10.0.0.3", "10.0.0.4", "10.0.0.5", "10.0.0.6", "10.0.0.7"]);
245
245
  });
246
246
  it("test_method_size", () => {
247
247
  const ip = IPAddress.parse("10.0.0.1/29");
248
- assertArrayEqual(ip.size().num, Crunchy.parse("8").num);
248
+ assert.isOk(ip!.size().eq(Crunchy.parse("8")));
249
249
  });
250
250
  it("test_method_network_u32", () => {
251
251
  assert.equal("2886732288", setup().ip.network().host_address.toString());
@@ -256,25 +256,25 @@ describe("Ipv4Test", () => {
256
256
  it("test_method_include", () => {
257
257
  let ip = IPAddress.parse("192.168.10.100/24");
258
258
  const addr = IPAddress.parse("192.168.10.102/24");
259
- assert.equal(true, ip.includes(addr));
260
- assert.equal(false, ip.includes(IPAddress.parse("172.16.0.48")));
259
+ assert.equal(true, ip!.includes(addr!));
260
+ assert.equal(false, ip!.includes(IPAddress.parse("172.16.0.48")!));
261
261
  ip = IPAddress.parse("10.0.0.0/8");
262
- assert.equal(true, ip.includes(IPAddress.parse("10.0.0.0/9")));
263
- assert.equal(true, ip.includes(IPAddress.parse("10.1.1.1/32")));
264
- assert.equal(true, ip.includes(IPAddress.parse("10.1.1.1/9")));
265
- assert.equal(false, ip.includes(IPAddress.parse("172.16.0.0/16")));
266
- assert.equal(false, ip.includes(IPAddress.parse("10.0.0.0/7")));
267
- assert.equal(false, ip.includes(IPAddress.parse("5.5.5.5/32")));
268
- assert.equal(false, ip.includes(IPAddress.parse("11.0.0.0/8")));
262
+ assert.equal(true, ip!.includes(IPAddress.parse("10.0.0.0/9")!));
263
+ assert.equal(true, ip!.includes(IPAddress.parse("10.1.1.1/32")!));
264
+ assert.equal(true, ip!.includes(IPAddress.parse("10.1.1.1/9")!));
265
+ assert.equal(false, ip!.includes(IPAddress.parse("172.16.0.0/16")!));
266
+ assert.equal(false, ip!.includes(IPAddress.parse("10.0.0.0/7")!));
267
+ assert.equal(false, ip!.includes(IPAddress.parse("5.5.5.5/32")!));
268
+ assert.equal(false, ip!.includes(IPAddress.parse("11.0.0.0/8")!));
269
269
  ip = IPAddress.parse("13.13.0.0/13");
270
- assert.equal(false, ip.includes(IPAddress.parse("13.16.0.0/32")));
270
+ assert.equal(false, ip!.includes(IPAddress.parse("13.16.0.0/32")!));
271
271
  });
272
272
  it("test_method_include_all", () => {
273
273
  const ip = IPAddress.parse("192.168.10.100/24");
274
274
  const addr1 = IPAddress.parse("192.168.10.102/24");
275
275
  const addr2 = IPAddress.parse("192.168.10.103/24");
276
- assert.equal(true, ip.includes_all([addr1, addr2]));
277
- assert.equal(false, ip.includes_all([addr1, IPAddress.parse("13.16.0.0/32")]));
276
+ assert.equal(true, ip!.includes_all([addr1!, addr2!]));
277
+ assert.equal(false, ip!.includes_all([addr1!, IPAddress.parse("13.16.0.0/32")!]));
278
278
  });
279
279
  it("test_method_ipv4", () => {
280
280
  assert.equal(true, setup().ip.is_ipv4());
@@ -283,19 +283,19 @@ describe("Ipv4Test", () => {
283
283
  assert.equal(false, setup().ip.is_ipv6());
284
284
  });
285
285
  it("test_method_private", () => {
286
- assert.equal(true, IPAddress.parse("169.254.99.4/24").is_private());
287
- assert.equal(true, IPAddress.parse("192.168.10.50/24").is_private());
288
- assert.equal(true, IPAddress.parse("192.168.10.50/16").is_private());
289
- assert.equal(true, IPAddress.parse("172.16.77.40/24").is_private());
290
- assert.equal(true, IPAddress.parse("172.16.10.50/14").is_private());
291
- assert.equal(true, IPAddress.parse("10.10.10.10/10").is_private());
292
- assert.equal(true, IPAddress.parse("10.0.0.0/8").is_private());
293
- assert.equal(false, IPAddress.parse("192.168.10.50/12").is_private());
294
- assert.equal(false, IPAddress.parse("3.3.3.3").is_private());
295
- assert.equal(false, IPAddress.parse("10.0.0.0/7").is_private());
296
- assert.equal(false, IPAddress.parse("172.32.0.0/12").is_private());
297
- assert.equal(false, IPAddress.parse("172.16.0.0/11").is_private());
298
- assert.equal(false, IPAddress.parse("192.0.0.2/24").is_private());
286
+ assert.equal(true, IPAddress.parse("169.254.99.4/24")!.is_private());
287
+ assert.equal(true, IPAddress.parse("192.168.10.50/24")!.is_private());
288
+ assert.equal(true, IPAddress.parse("192.168.10.50/16")!.is_private());
289
+ assert.equal(true, IPAddress.parse("172.16.77.40/24")!.is_private());
290
+ assert.equal(true, IPAddress.parse("172.16.10.50/14")!.is_private());
291
+ assert.equal(true, IPAddress.parse("10.10.10.10/10")!.is_private());
292
+ assert.equal(true, IPAddress.parse("10.0.0.0/8")!.is_private());
293
+ assert.equal(false, IPAddress.parse("192.168.10.50/12")!.is_private());
294
+ assert.equal(false, IPAddress.parse("3.3.3.3")!.is_private());
295
+ assert.equal(false, IPAddress.parse("10.0.0.0/7")!.is_private());
296
+ assert.equal(false, IPAddress.parse("172.32.0.0/12")!.is_private());
297
+ assert.equal(false, IPAddress.parse("172.16.0.0/11")!.is_private());
298
+ assert.equal(false, IPAddress.parse("192.0.0.2/24")!.is_private());
299
299
  });
300
300
  it("test_method_octet", () => {
301
301
  assert.equal(setup().ip.parts()[0], 172);
@@ -325,10 +325,10 @@ describe("Ipv4Test", () => {
325
325
  assert.equal(setup().ip.dns_reverse(), "10.16.172.in-addr.arpa");
326
326
  });
327
327
  it("test_method_dns_rev_domains", () => {
328
- assertArrayEqual(IPAddress.parse("173.17.5.1/23").dns_rev_domains(), ["4.17.173.in-addr.arpa", "5.17.173.in-addr.arpa"]);
329
- assertArrayEqual(IPAddress.parse("173.17.1.1/15").dns_rev_domains(), ["16.173.in-addr.arpa", "17.173.in-addr.arpa"]);
330
- assertArrayEqual(IPAddress.parse("173.17.1.1/7").dns_rev_domains(), ["172.in-addr.arpa", "173.in-addr.arpa"]);
331
- assertArrayEqual(IPAddress.parse("173.17.1.1/29").dns_rev_domains(), [
328
+ assertArrayEqual(IPAddress.parse("173.17.5.1/23")!.dns_rev_domains(), ["4.17.173.in-addr.arpa", "5.17.173.in-addr.arpa"]);
329
+ assertArrayEqual(IPAddress.parse("173.17.1.1/15")!.dns_rev_domains(), ["16.173.in-addr.arpa", "17.173.in-addr.arpa"]);
330
+ assertArrayEqual(IPAddress.parse("173.17.1.1/7")!.dns_rev_domains(), ["172.in-addr.arpa", "173.in-addr.arpa"]);
331
+ assertArrayEqual(IPAddress.parse("173.17.1.1/29")!.dns_rev_domains(), [
332
332
  "0.1.17.173.in-addr.arpa",
333
333
  "1.1.17.173.in-addr.arpa",
334
334
  "2.1.17.173.in-addr.arpa",
@@ -338,11 +338,11 @@ describe("Ipv4Test", () => {
338
338
  "6.1.17.173.in-addr.arpa",
339
339
  "7.1.17.173.in-addr.arpa",
340
340
  ]);
341
- assertArrayEqual(IPAddress.parse("174.17.1.1/24").dns_rev_domains(), ["1.17.174.in-addr.arpa"]);
342
- assertArrayEqual(IPAddress.parse("175.17.1.1/16").dns_rev_domains(), ["17.175.in-addr.arpa"]);
343
- assertArrayEqual(IPAddress.parse("176.17.1.1/8").dns_rev_domains(), ["176.in-addr.arpa"]);
344
- assertArrayEqual(IPAddress.parse("177.17.1.1/0").dns_rev_domains(), ["in-addr.arpa"]);
345
- assertArrayEqual(IPAddress.parse("178.17.1.1/32").dns_rev_domains(), ["1.1.17.178.in-addr.arpa"]);
341
+ assertArrayEqual(IPAddress.parse("174.17.1.1/24")!.dns_rev_domains(), ["1.17.174.in-addr.arpa"]);
342
+ assertArrayEqual(IPAddress.parse("175.17.1.1/16")!.dns_rev_domains(), ["17.175.in-addr.arpa"]);
343
+ assertArrayEqual(IPAddress.parse("176.17.1.1/8")!.dns_rev_domains(), ["176.in-addr.arpa"]);
344
+ assertArrayEqual(IPAddress.parse("177.17.1.1/0")!.dns_rev_domains(), ["in-addr.arpa"]);
345
+ assertArrayEqual(IPAddress.parse("178.17.1.1/32")!.dns_rev_domains(), ["1.1.17.178.in-addr.arpa"]);
346
346
  });
347
347
  it("test_method_compare", () => {
348
348
  let ip1 = IPAddress.parse("10.1.1.1/8");
@@ -351,75 +351,75 @@ describe("Ipv4Test", () => {
351
351
  const ip4 = IPAddress.parse("10.1.1.1/8");
352
352
 
353
353
  // ip2 should be greater than ip1
354
- assert.equal(true, ip1.lt(ip2));
355
- assert.equal(false, ip1.gt(ip2));
356
- assert.equal(false, ip2.lt(ip1));
354
+ assert.equal(true, ip1!.lt(ip2!));
355
+ assert.equal(false, ip1!.gt(ip2!));
356
+ assert.equal(false, ip2!.lt(ip1!));
357
357
  // ip2 should be less than ip3
358
- assert.equal(true, ip2.lt(ip3));
359
- assert.equal(false, ip2.gt(ip3));
358
+ assert.equal(true, ip2!.lt(ip3!));
359
+ assert.equal(false, ip2!.gt(ip3!));
360
360
  // ip1 should be less than ip3
361
- assert.equal(true, ip1.lt(ip3));
362
- assert.equal(false, ip1.gt(ip3));
363
- assert.equal(false, ip3.lt(ip1));
361
+ assert.equal(true, ip1!.lt(ip3!));
362
+ assert.equal(false, ip1!.gt(ip3!));
363
+ assert.equal(false, ip3!.lt(ip1!));
364
364
  // ip1 should be equal to itself
365
- assert.equal(true, ip1.eq(ip1));
365
+ assert.equal(true, ip1!.eq(ip1!));
366
366
  // ip1 should be equal to ip4
367
- assert.equal(true, ip1.eq(ip4));
367
+ assert.equal(true, ip1!.eq(ip4!));
368
368
  // test sorting
369
- const res = [ip1, ip2, ip3].sort((a, b) => a.cmp(b));
369
+ const res = [ip1!, ip2!, ip3!].sort((a, b) => a.cmp(b));
370
370
  assertArrayEqual(IPAddress.to_string_vec(res), ["10.1.1.1/8", "10.1.1.1/16", "172.16.1.1/14"]);
371
371
  // test same prefix
372
372
  ip1 = IPAddress.parse("10.0.0.0/24");
373
373
  ip2 = IPAddress.parse("10.0.0.0/16");
374
374
  ip3 = IPAddress.parse("10.0.0.0/8");
375
375
  {
376
- const res = [ip1, ip2, ip3].sort((a, b) => a.cmp(b));
376
+ const res = [ip1!, ip2!, ip3!].sort((a, b) => a.cmp(b));
377
377
  assertArrayEqual(IPAddress.to_string_vec(res), ["10.0.0.0/8", "10.0.0.0/16", "10.0.0.0/24"]);
378
378
  }
379
379
  });
380
380
  it("test_method_minus", () => {
381
381
  const ip1 = IPAddress.parse("10.1.1.1/8");
382
382
  const ip2 = IPAddress.parse("10.1.1.10/8");
383
- assert.equal("9", ip2.sub(ip1).toString());
384
- assert.equal("9", ip1.sub(ip2).toString());
383
+ assert.equal("9", ip2!.sub(ip1!).toString());
384
+ assert.equal("9", ip1!.sub(ip2!).toString());
385
385
  });
386
386
  it("test_method_plus", () => {
387
387
  let ip1 = IPAddress.parse("172.16.10.1/24");
388
388
  let ip2 = IPAddress.parse("172.16.11.2/24");
389
- assertArrayEqual(IPAddress.to_string_vec(ip1.add(ip2)), ["172.16.10.0/23"]);
389
+ assertArrayEqual(IPAddress.to_string_vec(ip1!.add(ip2!)), ["172.16.10.0/23"]);
390
390
 
391
391
  ip2 = IPAddress.parse("172.16.12.2/24");
392
- assertArrayEqual(IPAddress.to_string_vec(ip1.add(ip2)), [ip1.network().to_string(), ip2.network().to_string()]);
392
+ assertArrayEqual(IPAddress.to_string_vec(ip1!.add(ip2!)), [ip1!.network().to_string(), ip2!.network().to_string()]);
393
393
 
394
394
  ip1 = IPAddress.parse("10.0.0.0/23");
395
395
  ip2 = IPAddress.parse("10.0.2.0/24");
396
- assertArrayEqual(IPAddress.to_string_vec(ip1.add(ip2)), ["10.0.0.0/23", "10.0.2.0/24"]);
396
+ assertArrayEqual(IPAddress.to_string_vec(ip1!.add(ip2!)), ["10.0.0.0/23", "10.0.2.0/24"]);
397
397
 
398
398
  ip1 = IPAddress.parse("10.0.0.0/23");
399
399
  ip2 = IPAddress.parse("10.0.2.0/24");
400
- assertArrayEqual(IPAddress.to_string_vec(ip1.add(ip2)), ["10.0.0.0/23", "10.0.2.0/24"]);
400
+ assertArrayEqual(IPAddress.to_string_vec(ip1!.add(ip2!)), ["10.0.0.0/23", "10.0.2.0/24"]);
401
401
 
402
402
  ip1 = IPAddress.parse("10.0.0.0/16");
403
403
  ip2 = IPAddress.parse("10.0.2.0/24");
404
- assertArrayEqual(IPAddress.to_string_vec(ip1.add(ip2)), ["10.0.0.0/16"]);
404
+ assertArrayEqual(IPAddress.to_string_vec(ip1!.add(ip2!)), ["10.0.0.0/16"]);
405
405
 
406
406
  ip1 = IPAddress.parse("10.0.0.0/23");
407
407
  ip2 = IPAddress.parse("10.1.0.0/24");
408
- assertArrayEqual(IPAddress.to_string_vec(ip1.add(ip2)), ["10.0.0.0/23", "10.1.0.0/24"]);
408
+ assertArrayEqual(IPAddress.to_string_vec(ip1!.add(ip2!)), ["10.0.0.0/23", "10.1.0.0/24"]);
409
409
  });
410
410
  it("test_method_netmask_equal", () => {
411
411
  const ip = IPAddress.parse("10.1.1.1/16");
412
- assert.equal(16, ip.prefix.num);
413
- const ip2 = ip.change_netmask("255.255.255.0");
414
- assert.equal(24, ip2.prefix.num);
412
+ assert.equal(16, ip!.prefix.num);
413
+ const ip2 = ip!.change_netmask("255.255.255.0");
414
+ assert.equal(24, ip2!.prefix.num);
415
415
  });
416
416
  it("test_method_split", () => {
417
417
  assert.isNull(setup().ip.split(0));
418
418
  assert.isNull(setup().ip.split(257));
419
419
 
420
- assertArrayEqual(IPAddress.to_string_vec(setup().ip.split(1)), [setup().ip.network().to_string()]);
420
+ assertArrayEqual(IPAddress.to_string_vec(setup().ip.split(1)!), [setup().ip.network().to_string()]);
421
421
 
422
- assertArrayEqual(IPAddress.to_string_vec(setup().network.split(8)), [
422
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.split(8)!), [
423
423
  "172.16.10.0/27",
424
424
  "172.16.10.32/27",
425
425
  "172.16.10.64/27",
@@ -430,7 +430,7 @@ describe("Ipv4Test", () => {
430
430
  "172.16.10.224/27",
431
431
  ]);
432
432
 
433
- assertArrayEqual(IPAddress.to_string_vec(setup().network.split(7)), [
433
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.split(7)!), [
434
434
  "172.16.10.0/27",
435
435
  "172.16.10.32/27",
436
436
  "172.16.10.64/27",
@@ -440,7 +440,7 @@ describe("Ipv4Test", () => {
440
440
  "172.16.10.192/26",
441
441
  ]);
442
442
 
443
- assertArrayEqual(IPAddress.to_string_vec(setup().network.split(6)), [
443
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.split(6)!), [
444
444
  "172.16.10.0/27",
445
445
  "172.16.10.32/27",
446
446
  "172.16.10.64/27",
@@ -448,42 +448,42 @@ describe("Ipv4Test", () => {
448
448
  "172.16.10.128/26",
449
449
  "172.16.10.192/26",
450
450
  ]);
451
- assertArrayEqual(IPAddress.to_string_vec(setup().network.split(5)), [
451
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.split(5)!), [
452
452
  "172.16.10.0/27",
453
453
  "172.16.10.32/27",
454
454
  "172.16.10.64/27",
455
455
  "172.16.10.96/27",
456
456
  "172.16.10.128/25",
457
457
  ]);
458
- assertArrayEqual(IPAddress.to_string_vec(setup().network.split(4)), [
458
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.split(4)!), [
459
459
  "172.16.10.0/26",
460
460
  "172.16.10.64/26",
461
461
  "172.16.10.128/26",
462
462
  "172.16.10.192/26",
463
463
  ]);
464
- assertArrayEqual(IPAddress.to_string_vec(setup().network.split(3)), ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/25"]);
465
- assertArrayEqual(IPAddress.to_string_vec(setup().network.split(2)), ["172.16.10.0/25", "172.16.10.128/25"]);
466
- assertArrayEqual(IPAddress.to_string_vec(setup().network.split(1)), ["172.16.10.0/24"]);
464
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.split(3)!), ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/25"]);
465
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.split(2)!), ["172.16.10.0/25", "172.16.10.128/25"]);
466
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.split(1)!), ["172.16.10.0/24"]);
467
467
  });
468
468
  it("test_method_subnet", () => {
469
469
  assert.isNull(setup().network.subnet(23));
470
470
  assert.isNull(setup().network.subnet(33));
471
471
  assert.isOk(setup().ip.subnet(30));
472
- assertArrayEqual(IPAddress.to_string_vec(setup().network.subnet(26)), [
472
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.subnet(26)!), [
473
473
  "172.16.10.0/26",
474
474
  "172.16.10.64/26",
475
475
  "172.16.10.128/26",
476
476
  "172.16.10.192/26",
477
477
  ]);
478
- assertArrayEqual(IPAddress.to_string_vec(setup().network.subnet(25)), ["172.16.10.0/25", "172.16.10.128/25"]);
479
- assertArrayEqual(IPAddress.to_string_vec(setup().network.subnet(24)), ["172.16.10.0/24"]);
478
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.subnet(25)!), ["172.16.10.0/25", "172.16.10.128/25"]);
479
+ assertArrayEqual(IPAddress.to_string_vec(setup().network.subnet(24)!), ["172.16.10.0/24"]);
480
480
  });
481
481
  it("test_method_supernet", () => {
482
482
  assert.isNull(setup().ip.supernet(24));
483
- assert.equal("0.0.0.0/0", setup().ip.supernet(0).to_string());
483
+ assert.equal("0.0.0.0/0", setup().ip.supernet(0)!.to_string());
484
484
  // assert.equal("0.0.0.0/0", setup().ip.supernet(-2).to_string());
485
- assert.equal("172.16.10.0/23", setup().ip.supernet(23).to_string());
486
- assert.equal("172.16.8.0/22", setup().ip.supernet(22).to_string());
485
+ assert.equal("172.16.10.0/23", setup().ip.supernet(23)!.to_string());
486
+ assert.equal("172.16.8.0/22", setup().ip.supernet(22)!.to_string());
487
487
  });
488
488
  it("test_classmethod_parse_u32", () => {
489
489
  for (const i of setup().decimal_values) {
@@ -491,8 +491,8 @@ describe("Ipv4Test", () => {
491
491
  const int = i[1];
492
492
  const ip = Ipv4.from_number(int, 32);
493
493
  const splitted = addr.split("/");
494
- const ip2 = ip.change_prefix(parseInt(splitted[1], 10));
495
- assert.equal(ip2.to_string(), addr);
494
+ const ip2 = ip!.change_prefix(parseInt(splitted[1], 10));
495
+ assert.equal(ip2!.to_string(), addr);
496
496
  }
497
497
  });
498
498
  it("test_classmethod_summarize", () => {
@@ -502,41 +502,41 @@ describe("Ipv4Test", () => {
502
502
  // Summarize homogeneous networks
503
503
  let ip1 = IPAddress.parse("172.16.10.1/24");
504
504
  let ip2 = IPAddress.parse("172.16.11.2/24");
505
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1, ip2])), ["172.16.10.0/23"]);
505
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1!, ip2!])), ["172.16.10.0/23"]);
506
506
 
507
507
  {
508
508
  const ip1 = IPAddress.parse("10.0.0.1/24");
509
509
  const ip2 = IPAddress.parse("10.0.1.1/24");
510
510
  const ip3 = IPAddress.parse("10.0.2.1/24");
511
511
  const ip4 = IPAddress.parse("10.0.3.1/24");
512
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1, ip2, ip3, ip4])), ["10.0.0.0/22"]);
512
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1!, ip2!, ip3!, ip4!])), ["10.0.0.0/22"]);
513
513
  }
514
514
  {
515
515
  const ip1 = IPAddress.parse("10.0.0.1/24");
516
516
  const ip2 = IPAddress.parse("10.0.1.1/24");
517
517
  const ip3 = IPAddress.parse("10.0.2.1/24");
518
518
  const ip4 = IPAddress.parse("10.0.3.1/24");
519
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip4, ip3, ip2, ip1])), ["10.0.0.0/22"]);
519
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip4!, ip3!, ip2!, ip1!])), ["10.0.0.0/22"]);
520
520
  }
521
521
 
522
522
  // Summarize non homogeneous networks
523
523
  ip1 = IPAddress.parse("10.0.0.0/23");
524
524
  ip2 = IPAddress.parse("10.0.2.0/24");
525
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1, ip2])), ["10.0.0.0/23", "10.0.2.0/24"]);
525
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1!, ip2!])), ["10.0.0.0/23", "10.0.2.0/24"]);
526
526
 
527
527
  ip1 = IPAddress.parse("10.0.0.0/16");
528
528
  ip2 = IPAddress.parse("10.0.2.0/24");
529
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1, ip2])), ["10.0.0.0/16"]);
529
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1!, ip2!])), ["10.0.0.0/16"]);
530
530
 
531
531
  ip1 = IPAddress.parse("10.0.0.0/23");
532
532
  ip2 = IPAddress.parse("10.1.0.0/24");
533
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1, ip2])), ["10.0.0.0/23", "10.1.0.0/24"]);
533
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1!, ip2!])), ["10.0.0.0/23", "10.1.0.0/24"]);
534
534
 
535
535
  ip1 = IPAddress.parse("10.0.0.0/23");
536
536
  ip2 = IPAddress.parse("10.0.2.0/23");
537
537
  let ip3 = IPAddress.parse("10.0.4.0/24");
538
538
  let ip4 = IPAddress.parse("10.0.6.0/24");
539
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1, ip2, ip3, ip4])), [
539
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1!, ip2!, ip3!, ip4!])), [
540
540
  "10.0.0.0/22",
541
541
  "10.0.4.0/24",
542
542
  "10.0.6.0/24",
@@ -546,7 +546,7 @@ describe("Ipv4Test", () => {
546
546
  const ip2 = IPAddress.parse("10.0.2.1/24");
547
547
  const ip3 = IPAddress.parse("10.0.3.1/24");
548
548
  const ip4 = IPAddress.parse("10.0.4.1/24");
549
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1, ip2, ip3, ip4])), [
549
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1!, ip2!, ip3!, ip4!])), [
550
550
  "10.0.1.0/24",
551
551
  "10.0.2.0/23",
552
552
  "10.0.4.0/24",
@@ -557,7 +557,7 @@ describe("Ipv4Test", () => {
557
557
  const ip2 = IPAddress.parse("10.0.2.1/24");
558
558
  const ip3 = IPAddress.parse("10.0.3.1/24");
559
559
  const ip4 = IPAddress.parse("10.0.4.1/24");
560
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip4, ip3, ip2, ip1])), [
560
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip4!, ip3!, ip2!, ip1!])), [
561
561
  "10.0.1.0/24",
562
562
  "10.0.2.0/23",
563
563
  "10.0.4.0/24",
@@ -568,19 +568,19 @@ describe("Ipv4Test", () => {
568
568
  ip2 = IPAddress.parse("10.10.2.1/24");
569
569
  ip3 = IPAddress.parse("172.16.0.1/24");
570
570
  ip4 = IPAddress.parse("172.16.1.1/24");
571
- assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1, ip2, ip3, ip4])), [
571
+ assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize([ip1!, ip2!, ip3!, ip4!])), [
572
572
  "10.0.1.0/24",
573
573
  "10.10.2.0/24",
574
574
  "172.16.0.0/23",
575
575
  ]);
576
576
 
577
- let ips = [IPAddress.parse("10.0.0.12/30"), IPAddress.parse("10.0.100.0/24")];
577
+ let ips = [IPAddress.parse("10.0.0.12/30")!, IPAddress.parse("10.0.100.0/24")!];
578
578
  assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize(ips)), ["10.0.0.12/30", "10.0.100.0/24"]);
579
579
 
580
- ips = [IPAddress.parse("172.16.0.0/31"), IPAddress.parse("10.10.2.1/32")];
580
+ ips = [IPAddress.parse("172.16.0.0/31")!, IPAddress.parse("10.10.2.1/32")!];
581
581
  assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize(ips)), ["10.10.2.1/32", "172.16.0.0/31"]);
582
582
 
583
- ips = [IPAddress.parse("172.16.0.0/32"), IPAddress.parse("10.10.2.1/32")];
583
+ ips = [IPAddress.parse("172.16.0.0/32")!, IPAddress.parse("10.10.2.1/32")!];
584
584
  assertArrayEqual(IPAddress.to_string_vec(IPAddress.summarize(ips)), ["10.10.2.1/32", "172.16.0.0/32"]);
585
585
  });
586
586
  it("test_classmethod_parse_classful", () => {
@@ -588,8 +588,8 @@ describe("Ipv4Test", () => {
588
588
  const ip = i[0];
589
589
  const prefix = i[1];
590
590
  const res = Ipv4.parse_classful(ip);
591
- assert.equal(prefix, res.prefix.num);
592
- assert.equal(`${ip}/${prefix}`, res.to_string());
591
+ assert.equal(prefix, res!.prefix.num);
592
+ assert.equal(`${ip}/${prefix}`, res!.to_string());
593
593
  }
594
594
  assert.isNull(Ipv4.parse_classful("192.168.256.257"));
595
595
  });