Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {Test} from "forge-std/Test.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {Bytes} from "@openzeppelin/contracts/utils/Bytes.sol";
contract BytesTest is Test {
using Bytes for bytes;
function testSymbolicEqual(bytes memory a) public pure {
assertTrue(Bytes.equal(a, a));
}
// INDEX OF
function testSymbolicIndexOf(bytes memory buffer, bytes1 s) public pure {
uint256 result = Bytes.indexOf(buffer, s);
if (buffer.length == 0) {
// Case 0: buffer is empty
assertEq(result, type(uint256).max);
} else if (result == type(uint256).max) {
// Case 1: search value could not be found
for (uint256 i = 0; i < buffer.length; ++i) assertNotEq(buffer[i], s);
} else {
// Case 2: search value was found
assertEq(buffer[result], s);
// search value is not present anywhere before the found location
for (uint256 i = 0; i < result; ++i) assertNotEq(buffer[i], s);
}
}
function testIndexOf(bytes memory buffer, bytes1 s, uint256 pos) public pure {
uint256 result = Bytes.indexOf(buffer, s, pos);
if (buffer.length == 0) {
// Case 0: buffer is empty
assertEq(result, type(uint256).max);
} else if (result == type(uint256).max) {
// Case 1: search value could not be found
for (uint256 i = pos; i < buffer.length; ++i) assertNotEq(buffer[i], s);
} else {
// Case 2: search value was found
assertEq(buffer[result], s);
// search value is not present anywhere before the found location
for (uint256 i = pos; i < result; ++i) assertNotEq(buffer[i], s);
}
}
function testSymbolicLastIndexOf(bytes memory buffer, bytes1 s) public pure {
uint256 result = Bytes.lastIndexOf(buffer, s);
if (buffer.length == 0) {
// Case 0: buffer is empty
assertEq(result, type(uint256).max);
} else if (result == type(uint256).max) {
// Case 1: search value could not be found
for (uint256 i = 0; i < buffer.length; ++i) assertNotEq(buffer[i], s);
} else {
// Case 2: search value was found
assertEq(buffer[result], s);
// search value is not present anywhere after the found location
for (uint256 i = result + 1; i < buffer.length; ++i) assertNotEq(buffer[i], s);
}
}
function testLastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) public pure {
uint256 result = Bytes.lastIndexOf(buffer, s, pos);
if (buffer.length == 0) {
// Case 0: buffer is empty
assertEq(result, type(uint256).max);
} else if (result == type(uint256).max) {
// Case 1: search value could not be found
for (uint256 i = 0; i <= Math.min(pos, buffer.length - 1); ++i) assertNotEq(buffer[i], s);
} else {
// Case 2: search value was found
assertEq(buffer[result], s);
// search value is not present anywhere after the found location
for (uint256 i = result + 1; i <= Math.min(pos, buffer.length - 1); ++i) assertNotEq(buffer[i], s);
}
}
// SLICES
function testSliceWithStartOnly(bytes memory buffer, uint256 start) public pure {
bytes memory originalBuffer = bytes.concat(buffer);
bytes memory result = buffer.slice(start);
// Original buffer was not modified
assertEq(buffer, originalBuffer);
// Should return bytes from start to end
assertEq(result.length, Math.saturatingSub(buffer.length, start));
// Verify content matches
for (uint256 i = 0; i < result.length; ++i) {
assertEq(result[i], buffer[start + i]);
}
}
function testSlice(bytes memory buffer, uint256 start, uint256 end) public pure {
bytes memory originalBuffer = bytes.concat(buffer);
bytes memory result = buffer.slice(start, end);
// Original buffer was not modified
assertEq(buffer, originalBuffer);
// Calculate expected bounds after sanitization
uint256 sanitizedEnd = Math.min(end, buffer.length);
uint256 sanitizedStart = Math.min(start, sanitizedEnd);
uint256 expectedLength = sanitizedEnd - sanitizedStart;
assertEq(result.length, expectedLength);
// Verify content matches when there's content to verify
for (uint256 i = 0; i < result.length; ++i) {
assertEq(result[i], buffer[sanitizedStart + i]);
}
}
function testSpliceWithStartOnly(bytes memory buffer, uint256 start) public pure {
bytes memory originalBuffer = bytes.concat(buffer);
bytes memory result = buffer.splice(start);
// Result should be the same object as input (modified in place)
assertEq(result, buffer);
// Should contain bytes from start to end, moved to beginning
assertEq(result.length, Math.saturatingSub(originalBuffer.length, start));
// Verify content matches moved content
for (uint256 i = 0; i < result.length; ++i) {
assertEq(result[i], originalBuffer[start + i]);
}
}
function testSplice(bytes memory buffer, uint256 start, uint256 end) public pure {
bytes memory originalBuffer = bytes.concat(buffer);
bytes memory result = buffer.splice(start, end);
// Result should be the same object as input (modified in place)
assertEq(result, buffer);
// Calculate expected bounds after sanitization
uint256 sanitizedEnd = Math.min(end, originalBuffer.length);
uint256 sanitizedStart = Math.min(start, sanitizedEnd);
uint256 expectedLength = sanitizedEnd - sanitizedStart;
assertEq(result.length, expectedLength);
// Verify content matches moved content
for (uint256 i = 0; i < result.length; ++i) {
assertEq(result[i], originalBuffer[sanitizedStart + i]);
}
}
// Convert to nibbles
function testSymbolictoNibbles(bytes memory input) public pure {
bytes memory nibbles = Bytes.toNibbles(input);
assertEq(nibbles.length, input.length * 2);
// reconstruct input by traversing nibbles
for (uint256 i = 0; i < input.length; ++i) {
bytes1 nible0 = nibbles[2 * i];
bytes1 nible1 = nibbles[2 * i + 1];
assertEq(uint8(nible0) >> 4, 0);
assertEq(uint8(nible1) >> 4, 0);
assertEq(input[i], bytes1((uint8(nible0) << 4) | uint8(nible1)));
}
}
function testReplace(bytes memory buffer, uint256 pos, bytes memory replacement) public pure {
bytes memory originalBuffer = bytes.concat(buffer);
bytes memory originalReplacement = bytes.concat(replacement);
bytes memory result = Bytes.replace(buffer, pos, replacement);
// Result should be the same object as input (modified in place)
assertEq(result, buffer);
// Buffer length should remain unchanged
assertEq(result.length, originalBuffer.length);
// The replacement is not modified
assertEq(replacement, originalReplacement);
for (uint256 i = 0; i < buffer.length; ++i) {
if (i < pos) {
assertEq(result[i], originalBuffer[i]);
} else if (i < pos + replacement.length) {
assertEq(result[i], replacement[i - pos]);
} else {
assertEq(result[i], originalBuffer[i]);
}
}
}
function testReplaceFull(
bytes memory buffer,
uint256 pos,
bytes memory replacement,
uint256 offset,
uint256 length
) public pure {
bytes memory originalBuffer = bytes.concat(buffer);
bytes memory originalReplacement = bytes.concat(replacement);
bytes memory result = Bytes.replace(buffer, pos, replacement, offset, length);
// Result should be the same object as input (modified in place)
assertEq(result, buffer);
// Buffer length should remain unchanged
assertEq(result.length, originalBuffer.length);
// The replacement is not modified
assertEq(replacement, originalReplacement);
for (uint256 i = 0; i < buffer.length; ++i) {
if (i < pos) {
assertEq(result[i], originalBuffer[i]);
} else if (i < pos + Math.min(Math.saturatingSub(replacement.length, offset), length)) {
assertEq(result[i], replacement[i - pos + offset]);
} else {
assertEq(result[i], originalBuffer[i]);
}
}
}
// REVERSE BITS
function testSymbolicReverseBytes32(bytes32 value) public pure {
assertEq(Bytes.reverseBytes32(Bytes.reverseBytes32(value)), value);
}
function testSymbolicReverseBytes16(bytes16 value) public pure {
assertEq(Bytes.reverseBytes16(Bytes.reverseBytes16(value)), value);
}
function testSymbolicReverseBytes16Dirty(bytes16 value) public pure {
assertEq(Bytes.reverseBytes16(Bytes.reverseBytes16(_dirtyBytes16(value))), value);
assertEq(Bytes.reverseBytes16(_dirtyBytes16(Bytes.reverseBytes16(value))), value);
}
function testSymbolicReverseBytes8(bytes8 value) public pure {
assertEq(Bytes.reverseBytes8(Bytes.reverseBytes8(value)), value);
}
function testSymbolicReverseBytes8Dirty(bytes8 value) public pure {
assertEq(Bytes.reverseBytes8(Bytes.reverseBytes8(_dirtyBytes8(value))), value);
assertEq(Bytes.reverseBytes8(_dirtyBytes8(Bytes.reverseBytes8(value))), value);
}
function testSymbolicReverseBytes4(bytes4 value) public pure {
assertEq(Bytes.reverseBytes4(Bytes.reverseBytes4(value)), value);
}
function testSymbolicReverseBytes4Dirty(bytes4 value) public pure {
assertEq(Bytes.reverseBytes4(Bytes.reverseBytes4(_dirtyBytes4(value))), value);
assertEq(Bytes.reverseBytes4(_dirtyBytes4(Bytes.reverseBytes4(value))), value);
}
function testSymbolicReverseBytes2(bytes2 value) public pure {
assertEq(Bytes.reverseBytes2(Bytes.reverseBytes2(value)), value);
}
function testSymbolicReverseBytes2Dirty(bytes2 value) public pure {
assertEq(Bytes.reverseBytes2(Bytes.reverseBytes2(_dirtyBytes2(value))), value);
assertEq(Bytes.reverseBytes2(_dirtyBytes2(Bytes.reverseBytes2(value))), value);
}
// CLZ (Count Leading Zeros)
function testClz(bytes memory buffer) public pure {
uint256 result = Bytes.clz(buffer);
// index and offset of the first non zero bit
uint256 index = result / 8;
uint256 offset = result % 8;
// Result should never exceed buffer length
assertLe(index, buffer.length);
// All bytes before index position must be zero
for (uint256 i = 0; i < index; ++i) {
assertEq(buffer[i], 0);
}
// If index < buffer.length, byte at index position must be non-zero
if (index < buffer.length) {
// bit at position offset must be non zero
bytes1 singleBitMask = bytes1(0x80) >> offset;
assertEq(buffer[index] & singleBitMask, singleBitMask);
// all bits before offset must be zero
bytes1 multiBitsMask = bytes1(0xff) << (8 - offset);
assertEq(buffer[index] & multiBitsMask, 0);
}
}
// Helpers
function _dirtyBytes16(bytes16 value) private pure returns (bytes16 dirty) {
assembly ("memory-safe") {
dirty := or(value, shr(128, not(0)))
}
}
function _dirtyBytes8(bytes8 value) private pure returns (bytes8 dirty) {
assembly ("memory-safe") {
dirty := or(value, shr(192, not(0)))
}
}
function _dirtyBytes4(bytes4 value) private pure returns (bytes4 dirty) {
assembly ("memory-safe") {
dirty := or(value, shr(224, not(0)))
}
}
function _dirtyBytes2(bytes2 value) private pure returns (bytes2 dirty) {
assembly ("memory-safe") {
dirty := or(value, shr(240, not(0)))
}
}
}