| 
									
										
										
										
											2020-07-05 17:26:26 -07:00
										 |  |  | describe("correct behavior", () => { | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |     test("typeof bigint", () => { | 
					
						
							|  |  |  |         expect(typeof 1n).toBe("bigint"); | 
					
						
							|  |  |  |     }); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-10-02 09:59:28 -04:00
										 |  |  |     test("bigint string coercion", () => { | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |         expect("" + 123n).toBe("123"); | 
					
						
							|  |  |  |     }); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |     test("arithmetic operators", () => { | 
					
						
							|  |  |  |         let bigint = 123n; | 
					
						
							|  |  |  |         expect(-bigint).toBe(-123n); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |         expect(12n + 34n).toBe(46n); | 
					
						
							|  |  |  |         expect(12n - 34n).toBe(-22n); | 
					
						
							|  |  |  |         expect(8n * 12n).toBe(96n); | 
					
						
							|  |  |  |         expect(123n / 10n).toBe(12n); | 
					
						
							|  |  |  |         expect(2n ** 3n).toBe(8n); | 
					
						
							|  |  |  |         expect(5n % 3n).toBe(2n); | 
					
						
							|  |  |  |         expect( | 
					
						
							|  |  |  |             45977665298704210987n + | 
					
						
							|  |  |  |                 (714320987142450987412098743217984576n / 4598741987421098765327980n) * 987498743n | 
					
						
							|  |  |  |         ).toBe(199365500239020623962n); | 
					
						
							|  |  |  |     }); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |     test("bitwise operators", () => { | 
					
						
							|  |  |  |         expect(12n & 5n).toBe(4n); | 
					
						
							|  |  |  |         expect(1n | 2n).toBe(3n); | 
					
						
							|  |  |  |         expect(5n ^ 3n).toBe(6n); | 
					
						
							|  |  |  |         expect(~1n).toBe(-2n); | 
					
						
							|  |  |  |     }); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |     test("increment operators", () => { | 
					
						
							|  |  |  |         let bigint = 1n; | 
					
						
							|  |  |  |         expect(bigint++).toBe(1n); | 
					
						
							|  |  |  |         expect(bigint).toBe(2n); | 
					
						
							|  |  |  |         expect(bigint--).toBe(2n); | 
					
						
							|  |  |  |         expect(bigint).toBe(1n); | 
					
						
							|  |  |  |         expect(++bigint).toBe(2n); | 
					
						
							|  |  |  |         expect(bigint).toBe(2n); | 
					
						
							|  |  |  |         expect(--bigint).toBe(1n); | 
					
						
							|  |  |  |         expect(bigint).toBe(1n); | 
					
						
							|  |  |  |     }); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |     test("weak equality operators", () => { | 
					
						
							|  |  |  |         expect(1n == 1n).toBeTrue(); | 
					
						
							|  |  |  |         expect(1n == 1).toBeTrue(); | 
					
						
							|  |  |  |         expect(1 == 1n).toBeTrue(); | 
					
						
							|  |  |  |         expect(1n == 1.23).toBeFalse(); | 
					
						
							|  |  |  |         expect(1.23 == 1n).toBeFalse(); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |         expect(1n != 1n).toBeFalse(); | 
					
						
							|  |  |  |         expect(1n != 1).toBeFalse(); | 
					
						
							|  |  |  |         expect(1 != 1n).toBeFalse(); | 
					
						
							|  |  |  |         expect(1n != 1.23).toBeTrue(); | 
					
						
							|  |  |  |         expect(1.23 != 1n).toBeTrue(); | 
					
						
							|  |  |  |     }); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |     test("strong equality operators", () => { | 
					
						
							|  |  |  |         expect(1n === 1n).toBeTrue(); | 
					
						
							|  |  |  |         expect(1n === 1).toBeFalse(); | 
					
						
							|  |  |  |         expect(1 === 1n).toBeFalse(); | 
					
						
							|  |  |  |         expect(1n === 1.23).toBeFalse(); | 
					
						
							|  |  |  |         expect(1.23 === 1n).toBeFalse(); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |         expect(1n !== 1n).toBeFalse(); | 
					
						
							|  |  |  |         expect(1n !== 1).toBeTrue(); | 
					
						
							|  |  |  |         expect(1 !== 1n).toBeTrue(); | 
					
						
							|  |  |  |         expect(1n !== 1.23).toBeTrue(); | 
					
						
							|  |  |  |         expect(1.23 !== 1n).toBeTrue(); | 
					
						
							|  |  |  |     }); | 
					
						
							| 
									
										
										
										
											2020-07-05 17:26:26 -07:00
										 |  |  | }); | 
					
						
							| 
									
										
										
										
											2020-06-06 01:14:10 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-07-05 17:26:26 -07:00
										 |  |  | describe("errors", () => { | 
					
						
							| 
									
										
										
										
											2020-07-06 07:37:45 -07:00
										 |  |  |     test("conversion to number", () => { | 
					
						
							|  |  |  |         expect(() => { | 
					
						
							|  |  |  |             +123n; | 
					
						
							|  |  |  |         }).toThrowWithMessage(TypeError, "Cannot convert BigInt to number"); | 
					
						
							|  |  |  |     }); | 
					
						
							| 
									
										
										
										
											2020-07-05 17:26:26 -07:00
										 |  |  | }); |