fluencelabs/crossmodule
1
0
Fork 0
mirror of https://github.com/fluencelabs/crossmodule synced 2025-04-24 13:42:15 +00:00
Code Issues Projects Releases Wiki Activity

AS update, test update

Browse Source
This commit is contained in:
DieMyst 2019-08-12 17:58:22 +03:00
parent d88d6a618b
commit d08b80b071
11 changed files with 1073 additions and 4652 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
as-pect.config.js Normal file
View File

@ -0,0 +1,69 @@
module.exports = {
/**
* A set of globs passed to the glob package that qualify typescript files for testing.
*/
include: ["assembly/__tests__/**/*.spec.ts"],
/**
* A set of globs passed to the glob package that quality files to be added to each test.
*/
add: ["assembly/__tests__/**/*.include.ts"],
/**
* All the compiler flags needed for this test suite. Make sure that a binary file is output.
*/
flags: {
/** To output a wat file, uncomment the following line. */
// "--textFile": ["output.wat"],
/** A runtime must be provided here. */
"--runtime": ["stub"] // Acceptable values are: full, half, stub (arena), and none
},
/**
* A set of regexp that will disclude source files from testing.
*/
disclude: [/node_modules/],
/**
* Add your required AssemblyScript imports here.
*/
imports: {},
/**
* All performance statistics reporting can be configured here.
*/
performance: {
/** Enable performance statistics gathering for every test. */
enabled: false,
/** Set the maximum number of samples to run for every test. */
maxSamples: 10000,
/** Set the maximum test run time in milliseconds for every test. */
maxTestRunTime: 5000,
/** Report the median time in the default reporter for every test. */
reportMedian: true,
/** Report the average time in milliseconds for every test. */
reportAverage: true,
/** Report the standard deviation for every test. */
reportStandardDeviation: false,
/** Report the maximum run time in milliseconds for every test. */
reportMax: false,
/** Report the minimum run time in milliseconds for every test. */
reportMin: false,
},
/**
* Add a custom reporter here if you want one. The following example is in typescript.
*
* @example
* import { TestReporter, TestGroup, TestResult, TestContext } from "as-pect";
*
* export class CustomReporter extends TestReporter {
* // implement each abstract method here
* public abstract onStart(suite: TestContext): void;
* public abstract onGroupStart(group: TestGroup): void;
* public abstract onGroupFinish(group: TestGroup): void;
* public abstract onTestStart(group: TestGroup, result: TestResult): void;
* public abstract onTestFinish(group: TestGroup, result: TestResult): void;
* public abstract onFinish(suite: TestContext): void;
* }
*/
// reporter: new CustomReporter(),
/**
* Specify if the binary wasm file should be written to the file system.
*/
outputBinary: false,
};

865
assembly/__tests__/as-pect.d.ts vendored Normal file
View File

@ -0,0 +1,865 @@
/**
* This function creates a test group in the test loader.
*
* @param {string} description - This is the name of the test group.
* @param {() => void} callback - A function that contains all of the closures for this test group.
*
* @example
*
* ```ts
* describe("my test suite", (): void => {
* // put your tests here
* });
* ```
*/
declare function describe(description: string, callback: () => void): void;
/**
* This function creates a test inside the given test group. It must be placed inside a describe
* block.
*
* @param {string} description - This is the name of the test, and should describe a behavior.
* @param {() => void} callback - A function that contains a set of expectations for this test.
*
* @example
*
* ```ts
* describe("the meaning of life", (): void => {
* it("should be 42", (): void => {
* // put your expectations here
* expect<i32>(29 + 13).toBe(42);
* });
* });
* ```
*/
declare function it(description: string, callback: () => void): void;
/**
* A test that does not run, and is longhand equivalent to using todo function without a
* callback. This test does not get run and is reported like a todo.
*
* @param {string} description - This is the name of the test, and should describe a behavior.
* @param {() => void} callback - A function that contains a set of expectations for this test.
*/
declare function xit(description: string, callback: () => void): void;
/**
* A test that does not run, and is longhand equivalent to using todo function without a
* callback. This test does not get run and is reported like a todo.
*
* @param {string} description - This is the name of the test, and should describe a behavior.
* @param {() => void} callback - A function that contains a set of expectations for this test.
*/
declare function xtest(description: string, callback: () => void): void;
/**
* This function creates a test inside the given test group. It must be placed inside a describe
* block.
*
* @param {string} description - This is the name of the test, and should describe a behavior.
* @param {() => void} callback - A function that contains a set of expectations for this test.
*
* @example
* ```ts
* describe("the meaning of life", (): void => {
* test("the value should be 42", (): void => {
* // put your expectations here
* expect<i32>(29 + 13).toBe(42);
* });
* });
* ```
*/
declare function test(description: string, callback: () => void): void;
/**
* This function creates a test that is expected to fail. This is useful to verify if a given
* behavior is expected to throw.
*
* @param {string} description - This is the name of the test, and should describe a behavior.
* @param {() => void} callback - A function that contains a set of expectations for this test.
* @param {string?} message - A message that describes why the test should fail.
*
* @example
*
* ```ts
* describe("the meaning of life", (): void => {
* throws("the value should be 42", (): void => {
* // put your expectations here
* expect<i32>(29 + 13).not.toBe(42);
* });
* });
* ```
*/
declare function throws(description: string, callback: () => void, message?: string): void;
/**
* This function creates a test that is expected to fail. This is useful to verify if a given
* behavior is expected to throw.
*
* @param {string} description - This is the name of the test, and should describe a behavior.
* @param {() => void} callback - A function that contains a set of expectations for this test.
* @param {string?} message - A message that describes why the test should fail.
*
* @example
*
* ```ts
* describe("the meaning of life", (): void => {
* itThrows("when the value should be 42", (): void => {
* // put your expectations here
* expect<i32>(29 + 13).not.toBe(42);
* }, "The value is actually 42.");
* });
* ```
*/
declare function itThrows(description: string, callback: () => void, message?: string): void;
/**
* This function creates a callback that is called before each individual test is run in this test
* group.
*
* @param {function} callback - The function to be run before each test in the current test group.
*
* @example
*
* ```ts
* // create a global
* var cat: Cat = new Cat();
*
* describe("cats", (): void => {
* beforeEach((): void => {
* cat.meow(1); // meow once per test
* });
* });
* ```
*/
declare function beforeEach(callback: () => void): void;
/**
* This function creates a callback that is called before the whole test group is run, and only
* once.
*
* @param {function} callback - The function to be run before each test in the current test group.
*
* @example
*
* ```ts
* // create a global
* var dog: Dog = null;
* describe("dogs", (): void => {
* beforeAll((): void => {
* dog = new Dog(); // create a single dog once before the tests start
* });
* });
* ```
*/
declare function beforeAll(callback: () => void): void;
/**
* This function creates a callback that is called after each individual test is run in this test
* group.
*
* @param {function} callback - The function to be run after each test in the current test group.
*
* @example
*
* ```ts
* // create a global
* var cat: Cat = new Cat();
*
* describe("cats", (): void => {
* afterEach((): void => {
* cat.sleep(12); // cats sleep a lot
* });
* });
* ```
*/
declare function afterEach(callback: () => void): void;
/**
* This function creates a callback that is called after the whole test group is run, and only
* once.
*
* @param {function} callback - The function to be run after each test in the current test group.
*
* @example
*
* ```ts
* // create a global
* var dog: Dog = null;
* describe("dogs", (): void => {
* afterAll((): void => {
* memory.free(changetype<usize>(dog)); // free some memory
* });
* });
* ```
*/
declare function afterAll(callback: () => void): void;
/**
* Describes a value and returns an expectation to test the value.
*
* @type {T} - The expectation's type.
* @param {T} actual - The value being tested.
*
* @example
*
* ```ts
* expect<i32>(42).not.toBe(-1, "42 should not be -1");
* expect<i32>(19 + 23).toBe(42, "19 + 23 should equal 42");
* ```
*/
declare function expect<T>(actual: T | null): Expectation<T>;
/**
* Describes a void function and returns an expectation to test the function.
*
* @param {() => void} callback - The callback being tested.
*
* @example
*
* ```ts
* expectFn((): void => unreachable()).toThrow("unreachables do not throw");
* expectFn((): void => {
* cat.meow();
* }).not.toThrow("Uhoh, cats can't meow!");;
* ```
*/
declare function expectFn(cb: () => void): Expectation<() => void>;
/**
* Describes a test that needs to be written.
*
* @param {string} description - The description of the test that needs to be written.
*/
declare function todo(description: string): void;
/**
* Logs a single value to the logger, and is stringified. It works for references, values, and
* strings.
*
* @type {T} - The type to be logged.
* @param {T | null} value - The value to be logged.
*
* @example
*
* ```ts
* log<string>("This is a logged value.");
* log<i32>(42);
* log<Vec3>(new Vec(1, 2, 3));
* log<Vec3>(null);
* ```
*/
declare function log<T>(value: T | null): void;
/**
* An expectation for a value.
*/
// @ts-ignore
declare class Expectation<T> {
/**
* Create a new expectation.
*
* @param {T | null} actual - The actual value of the expectation.
*/
constructor(actual: T | null);
/**
* This expectation performs a strict equality on value types and reference types.
*
* @param {T | null} expected - The value to be compared.
* @param {string} message - The optional message that describes the expectation.
*
* @example
*
* ```ts
* expect<i32>(42).not.toBe(-1, "42 should not be -1");
* expect<i32>(19 + 23).toBe(42, "19 + 23 should equal 42");
* ```
*/
toBe(expected: T | null, message?: string): void;
/**
* This expectation performs a strict equality on value types and performs a memcompare on
* reference types. If the reference type `T` has reference types as properties, the comparison does
* not perform property traversal. It will only compare the pointer values in the memory block, and
* only compare `offsetof<T>()` bytes, regardless of the allocated block size.
*
* @param {T | null} expected - The value to be compared.
* @param {string} message - The optional message that describes the expectation.
*
* @example
*
* ```ts
* expect<Vec3>(new Vec3(1, 2, 3)).toStrictEqual(new Vec(1, 2, 3), "Vectors of the same shape should be equal");
* ```
*/
toStrictEqual(expected: T | null, message?: string): void;
/**
* This expectation performs a strict memory block equality based on the allocated block sizes.
*
* @param {T | null} expected - The value to be compared.
* @param {string} message - The optional message that describes the expectation.
*
* @example
*
* ```ts
* expect<Vec3>(new Vec3(1, 2, 3)).toBlockEqual(new Vec(1, 2, 3), "Vectors of the same shape should be equal");
* ```
*/
toBlockEqual(expected: T | null, message?: string): void;
/**
* If the value is callable, it calls the function, and fails the expectation if it throws, or hits
* an unreachable().
*
* @param {string} message - The optional message that describes the expectation.
*
* @example
*
* ```ts
* expectFn((): void => unreachable()).toThrow("unreachable() should throw.");
* expectFn((): void => {
* cat.sleep(100); // cats can sleep quite a lot
* }).not.toThrow("cats should sleep, not throw");
* ```
*/
toThrow(message?: string): void;
/**
* This expecation asserts that the value is truthy, like in javascript. If the value is a string,
* then strings of length 0 are not truthy.
*
* @param {string} message - The optional message that describes the expectation.
*
* @example
*
* ```ts
* expect<bool>(true).toBeTruthy("true is truthy.");
* expect<i32>(1).toBeTruthy("numeric values that are not 0 are truthy.");
* expect<Vec3>(new Vec3(1, 2, 3)).toBeTruthy("reference types that aren't null are truthy.");
* expect<bool>(false).not.toBeTruthy("false is not truthy.");
* expect<i32>(0).not.toBeTruthy("0 is not truthy.");
* expect<Vec3>(null).not.toBeTruthy("null is not truthy.");
* ```
*/
toBeTruthy(message?: string): void;
/**
* This expectation tests the value to see if it is null. If the value is a value type, it is
* never null. If the value is a reference type, it performs a strict null comparison.
*
* @param {string} message - The optional message that describes the expectation.
*
* @example
*
* ```ts
* expect<i32>(0).not.toBeNull("numbers are never null");
* expect<Vec3>(null).toBeNull("null reference types are null.");
* ```
*/
toBeNull(message?: string): void;
/**
* This expecation assert that the value is falsy, like in javascript. If the value is a string,
* then strings of length 0 are falsy.
*
* @param {string} message - The optional message that describes the expectation.
*
* @example
*
* ```ts
* expect<bool>(false).toBeFalsy("false is falsy.");
* expect<i32>(0).toBeFalsy("0 is falsy.");
* expect<Vec3>(null).toBeFalsy("null is falsy.");
* expect<bool>(true).not.toBeFalsy("true is not falsy.");
* expect<i32>(1).not.toBeFalsy("numeric values that are not 0 are not falsy.");
* expect<Vec3>(new Vec3(1, 2, 3)).not.toBeFalsy("reference types that aren't null are not falsy.");
* ```
*/
toBeFalsy(message?: string): void;
/**
* This expectation asserts that the value is greater than the expected value. Since operators can
* be overloaded in assemblyscript, it's possible for this to work on reference types.
*
* @param {T | null} expected - The expected value that the actual value should be greater than.
* @param {string} message - The optional message that describes this expectation.
*
* @example
*
* ```ts
* expect<i32>(10).toBeGreaterThan(4);
* expect<i32>(12).not.toBeGreaterThan(42);
* ```
*/
toBeGreaterThan(expected: T | null, message?: string): void;
/**
* This expectation asserts that the value is less than the expected value. Since operators can
* be overloaded in assemblyscript, it's possible for this to work on reference types.
*
* @param {T | null} value - The expected value that the actual value should be less than.
* @param {string} message - The optional message that describes this expectation.
*
* @example
*
* ```ts
* expect<i32>(10).not.toBeLessThan(4);
* expect<i32>(12).toBeLessThan(42);
* ```
*/
toBeLessThan(expected: T | null, message?: string): void;
/**
* This expectation asserts that the value is greater than or equal to the expected value. Since
* operators can be overloaded in assemblyscript, it's possible for this to work on reference
* types.
*
* @param {T | null} value - The expected value that the actual value should be greater than or
* equal to.
* @param {string} message - The optional message that describes this expectation.
*
* @example
*
* ```ts
* expect<i32>(42).toBeGreaterThanOrEqual(42);
* expect<i32>(10).toBeGreaterThanOrEqual(4);
* expect<i32>(12).not.toBeGreaterThanOrEqual(42);
* ```
*/
toBeGreaterThanOrEqual(expected: T | null, message?: string): void;
/**
* This expectation asserts that the value is less than or equal to the expected value. Since
* operators can be overloaded in assemblyscript, it's possible for this to work on reference
* types.
*
* @param {T | null} value - The expected value that the actual value should be less than or equal
* to.
* @param {string} message - The optional message that describes this expectation.
*
* @example
*
* ```ts
* expect<i32>(42).toBeLessThanOrEqual(42);
* expect<i32>(10).not.toBeLessThanOrEqual(4);
* expect<i32>(12).toBeLessThanOrEqual(42);
* ```
*/
toBeLessThanOrEqual(expected: T | null, message?: string): void;
/**
* This expectation asserts that the value is close to another value. Both numbers must be finite,
* and T must extend f64 or f32.
*
* @param {T extends f64 | f32} value - The expected value to be close to.
* @param {i32} decimalPlaces - The number of decimal places used to calculate epsilon. Default is
* 2.
* @param {string} message - The optional message that describes this expectation.
*
* @example
*
* ```ts
* expect<f64>(0.1 + 0.2).toBeCloseTo(0.3);
* ```
*/
toBeCloseTo(expected: T, decimalPlaces?: number, message?: string): void;
/**
* This function asserts the float type value is NaN.
*
* @param {string} message - The optional message the describes this expectation.
*
* @example
*
* ```ts
* expect<f64>(NaN).toBeNaN();
* expect<f32>(42).not.toBeNaN();
* ```
*/
toBeNaN(message?: string): void;
/**
* This function asserts a float is finite.
*
* @param {string} message - The optional message the describes this expectation.
* @example
*
* ```ts
* expect<f32>(42).toBeFinite();
* expect<f64>(Infinity).not.toBeFinite();
* ```
*/
toBeFinite(message?: string): void;
/**
* This method asserts the item has the expected length.
*
* @param {i32} expected - The expected length.
* @param {string} message - The optional message the describes this expectation.
*
* ```ts
* expect<i32[]>([1, 2, 3]).toHaveLength(3);
* ```
*/
toHaveLength(expected: i32, message?: string): void;
/**
* This method asserts that a given T that extends `Array<U>` has a value/reference included.
*
* @param {valueof<T>} expected - The expected item to be included in the Array.
* @param {string} message - The optional message the describes this expectation.
*
* @example
*
* ```ts
* expect<i32[]>([1, 2, 3]).toInclude(3);
* ```
*/
// @ts-ignore: expected value should be known at compile time
toInclude(expected: valueof<T>, message?: string): void;
/**
* This method asserts that a given T that extends `Array<U>` has a value/reference included.
*
* @param {valueof<T>} expected - The expected item to be included in the Array.
* @param {string} message - The optional message the describes this expectation.
*
* @example
*
* ```ts
* expect<i32[]>([1, 2, 3]).toContain(3);
* ```
*/
// @ts-ignore: expected value should be known at compile time
toContain(expected: valueof<T>, message?: string): void;
/**
* This method asserts that a given T that extends `Array<U>` has a value/reference included and
* compared via memory.compare().
*
* @param {i32} expected - The expected item to be included in the Array.
* @param {string} message - The optional message the describes this expectation.
*
* @example
* ```ts
* expect<Vec3[]>([new Vec3(1, 2, 3)]).toInclude(new Vec3(1, 2, 3));
* ```
*/
// @ts-ignore: expected value should be known at compile time
toIncludeEqual(expected: valueof<T>, message?: string): void;
/**
* This method asserts that a given T that extends `Array<U>` has a value/reference included and
* compared via memory.compare().
*
* @param {i32} expected - The expected item to be included in the Array.
* @param {string} message - The optional message the describes this expectation.
*
* @example
* ```ts
* expect<Vec3[]>([new Vec3(1, 2, 3)]).toInclude(new Vec3(1, 2, 3));
* ```
*/
// @ts-ignore: expected value should be known at compile time
toContainEqual(expected: valueof<T>, message?: string): void;
/**
* This computed property is chainable, and negates the existing expectation. It returns itself.
*
* @example
* ```ts
* expect<i32>(42).not.toBe(0, "42 is not 0");
*/
not: Expectation<T>;
/**
* The actual value of the expectation.
*/
actual: T | null;
}
/**
* This is called to stop the debugger. e.g. `node --inspect-brk asp`.
*/
declare function debug(): void;
/**
* This class contains a set of methods related to performance configuration.
*/
// @ts-ignore
declare class Performance {
/**
* This function call enables performance statistics gathering for the following test.
*
* @param {bool} enabled - The bool to indicate if performance statistics should be gathered.
*/
public static enabled(enabled: bool): void;
/**
* This function call sets the maximum number of samples to complete the following test.
*
* @param {f64} count - The maximum number of samples required.
*/
public static maxSamples(count: f64): void;
/**
* This function call sets the number of decimal places to round to for the following test.
*
* @param {i32} deicmalPlaces - The number of decimal places to round to
*/
public static roundDecimalPlaces(count: i32): void;
/**
* This function call will set the maximum amount of time that should pass before it can stop
* gathering samples for the following test.
*
* @param {f64} time - The ammount of time in milliseconds.
*/
public static maxTestRunTime(time: f64): void;
/**
* This function call enables gathering the average/mean run time of each sample for the following
* test.
*
* @param {bool} enabled - The bool to indicate if the average/mean should be gathered.
*/
public static reportAverage(enabled: bool): void;
/**
* This function call enables gathering the median run time of each sample for the following test.
*
* @param {bool} enabled - The bool to indicate if the median should be gathered.
*/
public static reportMedian(value: bool): void;
/**
* This function call enables gathering the standard deviation of the run times of the samples
* collected for the following test.
*
* @param {bool} enabled - The bool to indicate if the standard deviation should be gathered.
*/
public static reportStdDev(value: bool): void;
/**
* This function call enables gathering the largest run time of the samples collected for the
* following test.
*
* @param {bool} enabled - The bool to indicate if the max should be gathered.
*/
public static reportMax(value: bool): void;
/**
* This function call enables gathering the smallest run time of the samples collected for the
* following test.
*
* @param {bool} enabled - The bool to indicate if the min should be gathered.
*/
public static reportMin(value: bool): void;
/**
* This function call enables gathering the varaince of the samples collected for the following test.
*
* @param {bool} enabled - The bool to indicate if the variance should be calculated.
*/
public static reportVariance(value: bool): void;
}
/**
* Assemblyscript uses reference counting to perform garbage collection. This means when you
* allocate a managed object and return it, it's reference count is one. If another variable aliases
* it then the reference count goes up. This static class contains a few convenience methods for
* developers to test the current number of blocks allocated on the heap to make sure you aren't leaking
* references, e.i. keeping references to objects you expect to be collected.
*/
declare class RTrace {
/**
* This bool indicates if `RTrace` should call into JavaScript to obtain reference counts.
*/
public static enabled: bool;
/**
* This method returns the current number of active references on the heap.
*/
public static count(): i32;
/**
* This method starts a new refcounting group, and causes the next call to `RTrace.end(label)` to
* return a delta in reference counts on the heap.
*
* @param {i32} label - The numeric label for this refcounting group.
*/
public static start(label: i32): void;
/**
* This method returns a delta of how many new (positive) or collected (negative) are on the heap.
*
* @param {i32} label - The numeric label for this refcounting group.
*/
public static end(label: i32): i32;
/**
* This method returns the number of increments that have occurred over the course of a test
* file.
*/
public static increments(): i32;
/**
* This method returns the number of decrements that have occurred over the course of a test
* file.
*/
public static decrements(): i32;
/**
* This method returns the number of increments that have occurred over the course of a test
* group.
*/
public static groupIncrements(): i32;
/**
* This method returns the number of decrements that have occurred over the course of a test
* group.
*/
public static groupDecrements(): i32;
/**
* This method returns the number of increments that have occurred over the course of a test
* group.
*/
public static testIncrements(): i32;
/**
* This method returns the number of decrements that have occurred over the course of a test
* group.
*/
public static testDecrements(): i32;
/**
* This method returns the number of allocations that have occurred over the course of a test
* file.
*/
public static allocations(): i32;
/**
* This method returns the number of frees that have occurred over the course of a test
* file.
*/
public static frees(): i32;
/**
* This method returns the number of allocations that have occurred over the course of a test
* group.
*/
public static groupAllocations(): i32;
/**
* This method returns the number of frees that have occurred over the course of a test
* group.
*/
public static groupFrees(): i32;
/**
* This method returns the number of allocations that have occurred over the course of a test
* group.
*/
public static testAllocations(): i32;
/**
* This method returns the number of frees that have occurred over the course of a test
* group.
*/
public static testFrees(): i32;
/**
* This method triggers a garbage collection.
*/
public static collect(): void;
/**
* Get the class id of the pointer.
*
* @param {usize} pointer - The pointer.
* @returns {u32} - The class id of the allocated block.
*/
public static classIdOf(pointer: usize): u32;
/**
* Get the size of a block or buffer.
*
* @param {T} reference - The reference.
* @returns {u32} - The size of the allocated block.
*/
public static sizeOf<T>(reference: T): u32;
/**
* Get the currently allocated blocks.
*/
public static activeBlocks(): usize[];
/**
* Get the current groups allocated blocks.
*/
public static activeGroupBlocks(): usize[];
/**
* Get the current tests allocated blocks.
*/
public static activeTestBlocks(): usize[];
}
/**
* This class is static and contains private global values that contain metadata about the Actual
* value.
*
* @example
* ```ts
* Actual.report<string>("This is an expected string.");
* Actual.report<i32[]>([1, 2, 3]);
* Actual.report<u8>(42);
* ```
*/
declare class Actual {
/**
* This function performs reporting to javascript what the actual value of this expectation is.
*
* @param {T} actual - The actual value to be reported.
*/
public static report<T>(value: T): void;
/**
* Clear the actual value and release any private memory stored as a global.
*/
public static clear(): void;
}
/**
* This class is static and contains private global values that contain metadata about the Expected
* value.
*
* @example
* ```ts
* Expected.report<string>("This is an expected string.");
* Expected.report<i32[]>([1, 2, 3]);
* Expected.report<u8>(42, i32(true)); // not 42
* ```
*/
declare class Expected {
/**
* This function performs reporting to javascript what the expected value of this expectation is.
* It notifies javascript if the expectation is negated.
*
* @param {T} value - The actual value to be reported.
* @param {i32} negated - An indicator if the expectation is negated. Pass `1` to negate the
* expectation. (default: 0)
*/
public static report<T>(value: T, negated?: i32): void;
/**
* Clear the expected value and release any private memory stored as a global.
*/
public static clear(): void;
}

57
assembly/__tests__/crossmodule.spec.ts Normal file
View File

@ -0,0 +1,57 @@
import {API, StringInvoke} from "../index";
class SelfAPI extends API {
static getApi(): API {
let invokeImpl = (ptr: i32, size: i32): i32 => {
let resultPtr = __alloc(size + 4, 1);
let request = String.UTF8.decodeUnsafe(ptr, size);
let strBuf = Uint8Array.wrap(String.UTF8.encode(request));
let strLen: i32 = request.length;
for (let i = 0; i < 4; i++) {
let b: u8 = (strLen >> i * 8) as u8 & 0xFF;
store<u8>(resultPtr + i, b);
}
for (let i = 4; i < strLen + 3; i++) {
store<u8>(resultPtr + i, strBuf[i - 4]);
}
return resultPtr;
};
let allocateImpl = (size: i32) :i32 => {
return __alloc(size, 1);
};
let deallocateImpl = (ptr: i32, size: i32): void => {
__free(ptr);
};
let storeImpl = (ptr: i32, byte: u8): void => {
store<u8>(ptr, byte);
};
let loadImpl = (ptr: i32): u8 => {
return load<u8>(ptr);
};
return new API(invokeImpl, allocateImpl, deallocateImpl, storeImpl, loadImpl);
}
}
describe("crossmodule", () => {
it("input should be equal to output", () => {
let stringInvoker = new StringInvoke(SelfAPI.getApi());
let request = "some request hello";
let response = stringInvoker.invoke(request);
log<string>("request: " + request);
log<string>("response: " + response);
expect<string>(request).toStrictEqual(response, "request is equal to response");
});
});

21
assembly/index.ts
View File

@ -72,20 +72,20 @@ export class ByteInvoke {
return resultBytes;
}
sendBytes(localPtr: i32, len: i32): i32 {
let addr = this.api.allocate(len);
sendBytes(buffer: Uint8Array): i32 {
let addr = this.api.allocate(buffer.byteLength);
for (let i = 0; i < len; i++) {
let b: u8 = load<u8>(localPtr + i) as u8;
for (let i = 0; i < buffer.byteLength; i++) {
let b: u8 = buffer[i];
this.api.store(addr + i, b);
}
return addr;
}
invoke(ptr: i32, len: i32): Uint8Array {
let requestPtr = this.sendBytes(ptr, len);
let resultPtr = this.api.invokeImpl(requestPtr, len);
invoke(buffer: Uint8Array): Uint8Array {
let requestPtr = this.sendBytes(buffer);
let resultPtr = this.api.invokeImpl(requestPtr, buffer.byteLength);
return this.getBytes(resultPtr);
}
}
@ -99,11 +99,10 @@ export class StringInvoke {
}
invoke(request: string): string {
let utf8ptr = request.toUTF8();
let len = request.length;
let buffer = String.UTF8.encode(request);
let resultBytes = this.byteInvoker.invoke(utf8ptr, len);
let resultBytes = this.byteInvoker.invoke(Uint8Array.wrap(buffer));
return String.fromUTF8(resultBytes.buffer.data, resultBytes.length);
return String.UTF8.decode(resultBytes.buffer);
}
}

4468
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

27
package.json
View File

@ -4,33 +4,20 @@
"description": "",
"main": "index.js",
"scripts": {
"asbuild:untouched": "asc assembly/index.ts -b build/untouched.wasm -t build/untouched.wat --sourceMap --validate --debug",
"asbuild:optimized": "asc assembly/index.ts -b build/optimized.wasm -t build/optimized.wat --sourceMap --validate --optimize",
"asbuild:untouched": "asc assembly/index.ts -b build/untouched.wasm -t build/untouched.wat --sourceMap --validate --debug --runtime stub",
"asbuild:optimized": "asc assembly/index.ts -b build/optimized.wasm -t build/optimized.wat --sourceMap --validate --optimize --runtime stub",
"asbuild": "npm run asbuild:untouched && npm run asbuild:optimized",
"asbuild:test": "npm run asbuild:test:crossmodule",
"asbuild:test:crossmodule": "npx asc tests/assembly/crossmodule-test.spec.as.ts -b tests/build/crossmodule-test.wasm -t tests/build/crossmodule-test.wat --validate --sourceMap --importMemory --debug",
"test": "npm run asbuild:test && ava -v --serial",
"test:ci": "npm run asbuild:test && ava --fail-fast --serial"
"test": "asp"
},
"author": "",
"license": "ISC",
"devDependencies": {
"@as-pect/assembly": "^2.3.1",
"@as-pect/cli": "^2.3.1",
"@as-pect/core": "^2.3.1",
"@types/node": "^10.12.3",
"assemblyscript": "fluencelabs/assemblyscript",
"assemblyscript": "assemblyscript/assemblyscript",
"ts-node": "^7.0.1",
"ava": "^1.4.0",
"typescript": "^3.1.6"
},
"ava": {
"compileEnhancements": true,
"extensions": [
"ts"
],
"require": [
"ts-node/register/transpile-only"
],
"files": [
"tests/**/*.spec.ts"
]
}
}

63
tests/assembly/crossmodule-test.spec.as.ts
View File

@ -1,63 +0,0 @@
import {API, StringInvoke} from "../../assembly/index";
import "allocator/arena";
declare function logStr(str: string): void;
class SelfAPI extends API {
static getApi(): API {
let invokeImpl = (ptr: i32, size: i32): i32 => {
let resultPtr = memory.allocate(size + 4);
let request = String.fromUTF8(ptr, size);
let strLen: i32 = request.length;
for (let i = 0; i < 4; i++) {
let b: u8 = (strLen >> i * 8) as u8 & 0xFF;
store<u8>(resultPtr + i, b);
}
let utf8ptr = request.toUTF8();
let len = request.length;
for (let i = 4; i < len + 4; i++) {
store<u8>(resultPtr + i, load<u8>(utf8ptr + i - 4));
}
logStr("size: " + size.toString());
return resultPtr;
};
let allocateImpl = (size: i32) :i32 => {
return memory.allocate(size);
};
let deallocateImpl = (ptr: i32, size: i32): void => {
memory.free(ptr);
};
let storeImpl = (ptr: i32, byte: u8): void => {
store<u8>(ptr, byte);
};
let loadImpl = (ptr: i32): u8 => {
return load<u8>(ptr);
};
return new API(invokeImpl, allocateImpl, deallocateImpl, storeImpl, loadImpl);
}
}
export class CrossModuleTest {
static shouldReturnRightResult(): bool {
let stringInvoker = new StringInvoke(SelfAPI.getApi());
let request = "some request hello";
let response = stringInvoker.invoke(request);
assert(request == response, ":(");
return true;
}
}

6
tests/assembly/tsconfig.json
View File

@ -1,6 +0,0 @@
{
"extends": "../../node_modules/assemblyscript/std/assembly.json",
"include": [
"./**/*.ts","*.ts"
]
}

3
tests/crossmodule.spec.ts
View File

@ -1,3 +0,0 @@
import { defineTestsFromModule } from './utils/spec';
defineTestsFromModule('crossmodule-test');

113
tests/utils/helpers.ts
View File

@ -1,113 +0,0 @@
/// <reference path="../types/webassembly/index.d.ts" />
import * as fs from 'fs';
import * as path from 'path';
import * as util from 'util';
import { demangle } from 'assemblyscript/lib/loader';
const DIGITALS_REGEXP = /([0-9]{1,})/g;
const UPPER_ALPHAS_REGEXP = /([A-Z]{1,})/g;
export type ImportEntries = { [key: string]: object };
export type ExportedEntry = { [key: string]: Function };
export type ExportedEntries = { [key: string]: ExportedEntry };
const readFile = util.promisify(fs.readFile);
const F64 = new Float64Array(1);
const U64 = new Uint32Array(F64.buffer);
export function decamelize(str: string): string {
const t = str
.replace(DIGITALS_REGEXP, ' $1')
.replace(UPPER_ALPHAS_REGEXP, m => ' ' + (m.length === 1 ? m.toLowerCase() : m));
return t.charAt(0).toUpperCase() + t.slice(1);
}
export async function setup(testFileName: string): Promise<ExportedEntries> {
const pathName = path.resolve(__dirname, `../build/${ testFileName }.wasm`);
const file = await readFile(pathName, null);
if (!WebAssembly.validate(file)) {
throw new Error(`WebAssembly binary "${ pathName }" file not valid!`);
}
const imports = buildImports(`${ testFileName }.spec.as`, new WebAssembly.Memory({ initial: 2 }));
const result = await WebAssembly.instantiate(file, imports);
return demangle<ExportedEntries>(result.instance.exports);
}
function unpackToString64(value: number): string {
F64[0] = value;
return U64[1].toString(16) + U64[0].toString(16);
}
function unpackToString128(lo: number, hi: number): string {
return `0x${ (unpackToString64(hi) + unpackToString64(lo)).padStart(32, '0') }`;
}
function getString(ptr: number, buffer: ArrayBuffer): string {
var U16 = new Uint16Array(buffer);
var U32 = new Uint32Array(buffer);
var dataLength = U32[ptr >>> 2];
var dataOffset = (ptr + 4) >>> 1;
var dataRemain = dataLength;
var parts = [];
const chunkSize = 1024;
while (dataRemain > chunkSize) {
let last = U16[dataOffset + chunkSize - 1];
let size = last >= 0xD800 && last < 0xDC00 ? chunkSize - 1 : chunkSize;
let part = U16.subarray(dataOffset, dataOffset += size);
parts.push(String.fromCharCode.apply(String, part));
dataRemain -= size;
}
return parts.join('') + String.fromCharCode.apply(String, U16.subarray(dataOffset, dataOffset + dataRemain));
}
function buildImports(name: string, memory: WebAssembly.Memory): ImportEntries {
const buffer = memory.buffer;
return {
env: {
memory,
abort(msgPtr: number, filePtr: number, line: number, column: number) {
if (msgPtr) {
throw new Error(
`Abort called by reason "${ getString(msgPtr, buffer) }" at ${ getString(filePtr, buffer) } [${ line }:${ column }]`
);
} else {
throw new Error(`Abort called at ${ getString(filePtr, buffer) } [${ line }:${ column }]`);
}
},
},
decoder: {
logStr(msgPtr: number) {
if (msgPtr) console.log(`[str]: ${ getString(msgPtr, buffer) }`);
},
logF64(value: number) {
console.log(`[f64]: ${ value }`);
},
},
encoder: {
logStr(msgPtr: number) {
if (msgPtr) console.log(`[str]: ${ getString(msgPtr, buffer) }`);
},
logF64(value: number) {
console.log(`[f64]: ${ value }`);
},
},
[name]: {
logF64(value: number) {
console.log(`[f64]: ${ value }`);
},
logStr(msgPtr: number) {
if (msgPtr) console.log(`[str]: ${ getString(msgPtr, buffer) }`);
},
logU128Packed(msgPtr: number, lo: number, hi: number) {
if (msgPtr) {
console.log(`[u128] ${ getString(msgPtr, buffer) }: ${ unpackToString128(lo, hi) }`);
} else {
console.log(`[u128]: ${ unpackToString128(lo, hi) }`);
}
}
}
};
}

33
tests/utils/spec.ts
View File

@ -1,33 +0,0 @@
import test from 'ava';
import { setup, decamelize } from './helpers';
export async function defineTestsFromModule(moduleName: string) {
try {
const instance = await setup(moduleName);
for (const tests in instance) {
const testsInstance = instance[tests];
if (testsInstance.setUp) {
test.beforeEach(() => {
testsInstance.setUp();
});
}
if (testsInstance.tearDown) {
test.afterEach(() => {
testsInstance.tearDown();
});
}
for (const testName of Object.keys(testsInstance).filter(it => !(["setUp", "tearDown"].indexOf(it) != -1))) {
if (testName.startsWith("shouldAbort")) {
test(decamelize(testName), t => { t.throws(() => testsInstance[testName]()) });
} else {
test(decamelize(testName), t => t.truthy(testsInstance[testName]()));
}
}
}
} catch (e) {
console.log("Error loading WebAssembly module:", e);
throw e;
}
}