From 86f6f872c99a84547af754c66f3c9fc9f44cf4eb Mon Sep 17 00:00:00 2001
From: Denis Pushkarev <zloirock@zloirock.ru>
Date: Sat, 25 Nov 2023 15:25:19 +0700
Subject: [PATCH] add some tests

---
 .../esnext.uint8-array.from-base64.js         |  3 ++
 .../esnext.uint8-array.to-base64.js           | 32 +++++++++++++++++++
 .../unit-global/esnext.uint8-array.to-hex.js  | 16 ++++++++++
 3 files changed, 51 insertions(+)
 create mode 100644 tests/unit-global/esnext.uint8-array.to-base64.js
 create mode 100644 tests/unit-global/esnext.uint8-array.to-hex.js

diff --git a/tests/unit-global/esnext.uint8-array.from-base64.js b/tests/unit-global/esnext.uint8-array.from-base64.js
index 45bbac6d3e18..6de552dc5614 100644
--- a/tests/unit-global/esnext.uint8-array.from-base64.js
+++ b/tests/unit-global/esnext.uint8-array.from-base64.js
@@ -14,6 +14,9 @@ if (DESCRIPTORS) QUnit.test('Uint8Array.fromBase64', assert => {
 
   assert.deepEqual(fromBase64('SGVsbG8gV29ybGQ='), array, 'proper result');
 
+  assert.throws(() => fromBase64('1234', null), TypeError, 'incorrect options argument #1');
+  assert.throws(() => fromBase64('1234', 1), TypeError, 'incorrect options argument #2');
+
   assert.throws(() => fromBase64('1234', { alphabet: 'base32' }), TypeError, 'incorrect encoding');
 
   assert.deepEqual(fromBase64('12/3'), new Uint8Array([215, 111, 247]), 'encoding #1');
diff --git a/tests/unit-global/esnext.uint8-array.to-base64.js b/tests/unit-global/esnext.uint8-array.to-base64.js
new file mode 100644
index 000000000000..b9da9d6d96a9
--- /dev/null
+++ b/tests/unit-global/esnext.uint8-array.to-base64.js
@@ -0,0 +1,32 @@
+import { DESCRIPTORS } from '../helpers/constants.js';
+
+if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.toBase64', assert => {
+  const { toBase64 } = Uint8Array.prototype;
+  assert.isFunction(toBase64);
+  assert.arity(toBase64, 0);
+  assert.name(toBase64, 'toBase64');
+  assert.looksNative(toBase64);
+
+  const array = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);
+
+  assert.same(array.toBase64(), 'SGVsbG8gV29ybGQ=', 'proper result');
+  assert.same(array.toBase64({ alphabet: 'base64' }), 'SGVsbG8gV29ybGQ=', 'proper result, base64');
+  assert.same(array.toBase64({ alphabet: 'base64url' }), 'SGVsbG8gV29ybGQ=', 'proper result, base64url');
+
+  assert.throws(() => array.toBase64(null), TypeError, 'incorrect options argument #1');
+  assert.throws(() => array.toBase64(1), TypeError, 'incorrect options argument #2');
+
+  assert.throws(() => array.toBase64({ alphabet: 'base32' }), TypeError, 'incorrect encoding');
+
+  assert.same(new Uint8Array([215, 111, 247]).toBase64(), '12/3', 'encoding #1');
+  assert.same(new Uint8Array([215, 111, 247]).toBase64({ alphabet: 'base64' }), '12/3', 'encoding #2');
+  assert.same(new Uint8Array([215, 111, 247]).toBase64({ alphabet: 'base64url' }), '12_3', 'encoding #3');
+  assert.same(new Uint8Array([215, 111, 183]).toBase64(), '12+3', 'encoding #4');
+  assert.same(new Uint8Array([215, 111, 183]).toBase64({ alphabet: 'base64' }), '12+3', 'encoding #5');
+  assert.same(new Uint8Array([215, 111, 183]).toBase64({ alphabet: 'base64url' }), '12-3', 'encoding #6');
+
+  assert.throws(() => toBase64.call(null), TypeError, "isn't generic #1");
+  assert.throws(() => toBase64.call(undefined), TypeError, "isn't generic #2");
+  assert.throws(() => toBase64.call(new Int16Array([1])), TypeError, "isn't generic #3");
+  assert.throws(() => toBase64.call([1]), TypeError, "isn't generic #4");
+});
diff --git a/tests/unit-global/esnext.uint8-array.to-hex.js b/tests/unit-global/esnext.uint8-array.to-hex.js
new file mode 100644
index 000000000000..69b8db06e295
--- /dev/null
+++ b/tests/unit-global/esnext.uint8-array.to-hex.js
@@ -0,0 +1,16 @@
+import { DESCRIPTORS } from '../helpers/constants.js';
+
+if (DESCRIPTORS) QUnit.test('Uint8Array.prototype.toHex', assert => {
+  const { toHex } = Uint8Array.prototype;
+  assert.isFunction(toHex);
+  assert.arity(toHex, 0);
+  assert.name(toHex, 'toHex');
+  assert.looksNative(toHex);
+
+  assert.same(new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]).toHex(), '48656c6c6f20576f726c64', 'proper result');
+
+  assert.throws(() => toHex.call(null), TypeError, "isn't generic #1");
+  assert.throws(() => toHex.call(undefined), TypeError, "isn't generic #2");
+  assert.throws(() => toHex.call(new Int16Array([1])), TypeError, "isn't generic #3");
+  assert.throws(() => toHex.call([1]), TypeError, "isn't generic #4");
+});