BSV1.8

yzt

2023-09-27 726603df43447f8cfedfeaae4267209adbd01699

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
import { FeatureDetection } from "../../Source/Cesium.js";
import { HilbertOrder } from "../../Source/Cesium.js";
 
describe("Core/HilbertOrder", function () {
  /* eslint-disable no-undef */
  if (!FeatureDetection.supportsBigInt()) {
    return;
  }
 
  it("encode2D throws for undefined inputs", function () {
    expect(function () {
      return HilbertOrder.encode2D(undefined, 0, 0);
    }).toThrowDeveloperError();
    expect(function () {
      return HilbertOrder.encode2D(0, undefined, 0);
    }).toThrowDeveloperError();
    expect(function () {
      return HilbertOrder.encode2D(0, 0, undefined);
    }).toThrowDeveloperError();
  });
 
  it("encode2D throws for invalid level", function () {
    expect(function () {
      return HilbertOrder.encode2D(-1, 0, 0);
    }).toThrowDeveloperError();
    expect(function () {
      return HilbertOrder.encode2D(0, 0, 0);
    }).toThrowDeveloperError();
  });
 
  it("encode2D throws for invalid coordinates", function () {
    expect(function () {
      return HilbertOrder.encode2D(1, -1, 0);
    }).toThrowDeveloperError();
 
    expect(function () {
      return HilbertOrder.encode2D(0, -1, 0);
    }).toThrowDeveloperError();
 
    expect(function () {
      return HilbertOrder.encode2D(-1, -1, 0);
    }).toThrowDeveloperError();
 
    expect(function () {
      return HilbertOrder.encode2D(1, 2, 0);
    }).toThrowDeveloperError();
    expect(function () {
      return HilbertOrder.encode2D(1, 0, 2);
    }).toThrowDeveloperError();
    expect(function () {
      return HilbertOrder.encode2D(1, 2, 2);
    }).toThrowDeveloperError();
  });
 
  it("encode2D works", function () {
    expect(HilbertOrder.encode2D(1, 0, 0)).toEqual(BigInt(0));
    expect(HilbertOrder.encode2D(1, 0, 1)).toEqual(BigInt(1));
    expect(HilbertOrder.encode2D(1, 1, 1)).toEqual(BigInt(2));
    expect(HilbertOrder.encode2D(1, 1, 0)).toEqual(BigInt(3));
 
    expect(HilbertOrder.encode2D(2, 0, 0)).toEqual(BigInt(0));
    expect(HilbertOrder.encode2D(2, 1, 0)).toEqual(BigInt(1));
    expect(HilbertOrder.encode2D(2, 1, 1)).toEqual(BigInt(2));
    expect(HilbertOrder.encode2D(2, 0, 1)).toEqual(BigInt(3));
    expect(HilbertOrder.encode2D(2, 0, 2)).toEqual(BigInt(4));
    expect(HilbertOrder.encode2D(2, 0, 3)).toEqual(BigInt(5));
    expect(HilbertOrder.encode2D(2, 1, 3)).toEqual(BigInt(6));
    expect(HilbertOrder.encode2D(2, 1, 2)).toEqual(BigInt(7));
    expect(HilbertOrder.encode2D(2, 2, 2)).toEqual(BigInt(8));
    expect(HilbertOrder.encode2D(2, 2, 3)).toEqual(BigInt(9));
    expect(HilbertOrder.encode2D(2, 3, 3)).toEqual(BigInt(10));
    expect(HilbertOrder.encode2D(2, 3, 2)).toEqual(BigInt(11));
    expect(HilbertOrder.encode2D(2, 3, 1)).toEqual(BigInt(12));
    expect(HilbertOrder.encode2D(2, 2, 1)).toEqual(BigInt(13));
    expect(HilbertOrder.encode2D(2, 2, 0)).toEqual(BigInt(14));
    expect(HilbertOrder.encode2D(2, 3, 0)).toEqual(BigInt(15));
  });
 
  it("decode2D throws for invalid level", function () {
    expect(function () {
      return HilbertOrder.decode2D(-1, BigInt(0));
    }).toThrowDeveloperError();
    expect(function () {
      return HilbertOrder.decode2D(0, BigInt(0));
    }).toThrowDeveloperError();
  });
 
  it("decode2D throws for invalid index", function () {
    expect(function () {
      return HilbertOrder.decode2D(1, BigInt(4));
    }).toThrowDeveloperError();
  });
 
  it("decode2D works", function () {
    expect(HilbertOrder.decode2D(1, BigInt(0))).toEqual([0, 0]);
    expect(HilbertOrder.decode2D(1, BigInt(1))).toEqual([0, 1]);
    expect(HilbertOrder.decode2D(1, BigInt(2))).toEqual([1, 1]);
    expect(HilbertOrder.decode2D(1, BigInt(3))).toEqual([1, 0]);
    expect(HilbertOrder.decode2D(2, BigInt(0))).toEqual([0, 0]);
    expect(HilbertOrder.decode2D(2, BigInt(1))).toEqual([1, 0]);
    expect(HilbertOrder.decode2D(2, BigInt(2))).toEqual([1, 1]);
    expect(HilbertOrder.decode2D(2, BigInt(3))).toEqual([0, 1]);
    expect(HilbertOrder.decode2D(2, BigInt(4))).toEqual([0, 2]);
    expect(HilbertOrder.decode2D(2, BigInt(5))).toEqual([0, 3]);
    expect(HilbertOrder.decode2D(2, BigInt(6))).toEqual([1, 3]);
    expect(HilbertOrder.decode2D(2, BigInt(7))).toEqual([1, 2]);
    expect(HilbertOrder.decode2D(2, BigInt(8))).toEqual([2, 2]);
    expect(HilbertOrder.decode2D(2, BigInt(9))).toEqual([2, 3]);
    expect(HilbertOrder.decode2D(2, BigInt(10))).toEqual([3, 3]);
    expect(HilbertOrder.decode2D(2, BigInt(11))).toEqual([3, 2]);
    expect(HilbertOrder.decode2D(2, BigInt(12))).toEqual([3, 1]);
    expect(HilbertOrder.decode2D(2, BigInt(13))).toEqual([2, 1]);
    expect(HilbertOrder.decode2D(2, BigInt(14))).toEqual([2, 0]);
    expect(HilbertOrder.decode2D(2, BigInt(15))).toEqual([3, 0]);
  });
});