npm - jsf.js_next_gen - Versions diffs - 4.0.1-alpha.0 → 4.0.1-beta.1 - Mend

jsf.js_next_gen 4.0.1-alpha.0 → 4.0.1-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (115) hide show

package/src/main/typescript/test/frameworkBase/_ext/monadish/DomQueryTest.spec.ts CHANGED Viewed

@@ -16,21 +16,20 @@
 import {expect} from 'chai';
 import {describe, it} from 'mocha';
+import {ArrayCollector, DomQuery, DomQueryCollector, Lang, LazyStream} from "mona-dish";
+import trim = Lang.trim;
 import {from} from "rxjs";
-import {ArrayCollector, Config, DomQuery, DomQueryCollector, Lang, LazyStream, Stream} from "mona-dish";
-import {tobagoSheetWithHeader} from "./markups/tobago-with-header";
-import {tobagoSheetWithoutHeader} from "./markups/tobago-without-header";
 const jsdom = require("jsdom");
 const {JSDOM} = jsdom;
-import trim = Lang.trim;
 (global as any).window = {}
 let dom = null;
 describe('DOMQuery tests', function () {
     beforeEach(function () {
+        // language=HTML
         dom = new JSDOM(`
             <!DOCTYPE html>
         <html lang="en">
@@ -87,14 +86,14 @@ describe('DOMQuery tests', function () {
         let probe1 = new DomQuery(window.document.body);
         let probe2 = DomQuery.querySelectorAll("div");
-        let o1 = from(Stream.ofDataSource(probe1));
-        let o2 = from(Stream.ofDataSource(probe2));
+        let o1 = from(probe1.stream);
+        let o2 = from(probe2.stream);
         let cnt1 = 0;
         let isDQuery = false;
         let cnt2 = 0;
-        o1.subscribe((item: any) => {
+        o1.subscribe(() => {
             cnt1++;
         });
@@ -113,14 +112,14 @@ describe('DOMQuery tests', function () {
         let probe1 = new DomQuery(window.document.body);
         let probe2 = DomQuery.querySelectorAll("div");
-        let o1 = from(Stream.ofDataSource(probe1));
-        let o2 = from(Stream.ofDataSource(probe2));
+        let o1 = from(probe1.stream);
+        let o2 = from(probe2.stream);
         let cnt1 = 0;
         let isDQuery = false;
         let cnt2 = 0;
-        o1.subscribe((item: any) => {
+        o1.subscribe(() => {
             cnt1++;
         });
@@ -184,7 +183,7 @@ describe('DOMQuery tests', function () {
     it('domquery ops test2 eachNode', function () {
         let probe2 = DomQuery.querySelectorAll("div");
         let noIter = 0;
-        probe2 = probe2.each((item, cnt) => {
+        probe2.each((item, cnt) => {
             expect(item instanceof DomQuery).to.be.true;
             expect(noIter == cnt).to.be.true;
             noIter++;
@@ -299,61 +298,28 @@ describe('DOMQuery tests', function () {
         expect(DomQuery.querySelectorAll("#insertedAfter2").isPresent()).to.be.true;
     });
-    it('do not create new <html> tag on <header', function () {
-        const fromMarkupWithHeader = DomQuery.fromMarkup(tobagoSheetWithHeader);
-        const fromMarkupWithoutHeader = DomQuery.fromMarkup(tobagoSheetWithoutHeader);
-        expect(fromMarkupWithHeader.tagName.value === "HTML").to.be.false;
-        expect(fromMarkupWithoutHeader.tagName.value === "HTML").to.be.false;
-    });
-    it('do not falsely assume standard tag', function () {
-        const fromMarkup1 = DomQuery.fromMarkup(`
-        <head-mine>booga</head-mine>
-        `);
-        const fromMarkup2 = DomQuery.fromMarkup(`
-        <body_mine>booga</body_mine>
-        `);
-        expect(fromMarkup1.tagName.value === "HTML").to.be.false;
-        expect(fromMarkup1.tagName.value === "HTML").to.be.false;
-        expect(fromMarkup1.tagName.value === "HEAD").to.be.false;
-        expect(fromMarkup2.tagName.value === "BODY").to.be.false;
-    });
     it('it must stream', function () {
         let probe1 = new DomQuery(document).querySelectorAll("div");
-        let coll: Array<any> = Stream.ofDomQuery(probe1).collect(new ArrayCollector());
+        let coll: Array<any> = probe1.stream.collect(new ArrayCollector());
         expect(coll.length == 4).to.be.true;
-        coll = LazyStream.ofDomQuery(probe1).collect(new ArrayCollector());
+        coll = probe1.lazyStream.collect(new ArrayCollector());
         expect(coll.length == 4).to.be.true;
     });
-    it('it must stream - DQ API (dynamically added)', function () {
-        let probe1 = new DomQuery(document).querySelectorAll("div");
-        let coll: Array<any> = probe1.asArray;
-        expect(coll.length == 4).to.be.true;
-    });
     it('it must stream to a domquery', function () {
         let probe1 = new DomQuery(document).querySelectorAll("div");
-        let coll: DomQuery = Stream.ofDataSource(probe1).collect(new DomQueryCollector());
+        let coll: DomQuery = probe1.stream.collect(new DomQueryCollector());
         expect(coll.length == 4).to.be.true;
-        probe1.reset();
-        coll = LazyStream.ofStreamDataSource(probe1).collect(new DomQueryCollector());
+        coll = probe1.lazyStream.collect(new DomQueryCollector());
         expect(coll.length == 4).to.be.true;
     });
     it('it must have parents', function () {
         let probe1 = new DomQuery(document).querySelectorAll("div");
-        let coll: Array<any> = Stream.ofDataSource(probe1.parentsWhileMatch("body")).collect(new ArrayCollector());
+        let coll: Array<any> = probe1.firstParent("body").stream.collect(new ArrayCollector());
         expect(coll.length == 1).to.be.true;
     });
@@ -376,90 +342,22 @@ describe('DOMQuery tests', function () {
         expect(innerHtml.indexOf("id_x_1_1") > innerHtml.indexOf("id_x_0_1")).to.be.true;
     })
-    it("must have a working replace", function () {
-        let probe1 = new DomQuery(document).byId("id_1");
-        probe1.replace(DomQuery.fromMarkup(` <div id="id_x_0"></div><div id="id_x_1"></div>`));
-        expect(DomQuery.querySelectorAll("div").length).to.eq(5);
-        let innerHtml = DomQuery.querySelectorAll("body").innerHTML;
-        expect(innerHtml.indexOf("id_x_0") > 0).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") < innerHtml.indexOf("id_2")).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") < innerHtml.indexOf("id_3")).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") < innerHtml.indexOf("id_x_1")).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") > 0).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") < innerHtml.indexOf("id_2")).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") < innerHtml.indexOf("id_3")).to.be.true;
-        expect(innerHtml.indexOf("id_1") == -1).to.be.true;
-    })
-    it("must have a working replace - 2", function () {
-        let probe1 = new DomQuery(document).byId("id_2");
-        probe1.replace(DomQuery.fromMarkup(` <div id="id_x_0"></div><div id="id_x_1"></div>`));
-        expect(DomQuery.querySelectorAll("div").length).to.eq(5);
-        let innerHtml = DomQuery.querySelectorAll("body").innerHTML;
-        expect(innerHtml.indexOf("id_x_0") > innerHtml.indexOf("id_1")).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") > 0).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") > innerHtml.indexOf("id_0")).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") < innerHtml.indexOf("id_3")).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") > 0).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") > innerHtml.indexOf("id_0")).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") < innerHtml.indexOf("id_3")).to.be.true;
-        expect(innerHtml.indexOf("id_2") == -1).to.be.true;
-    })
-    it("must have a working replace - 3", function () {
-        let probe1 = new DomQuery(document).byId("id_4");
-        probe1.replace(DomQuery.fromMarkup(` <div id="id_x_0"></div><div id="id_x_1"></div>`));
-        expect(DomQuery.querySelectorAll("div").length).to.eq(5);
-        let innerHtml = DomQuery.querySelectorAll("body").innerHTML;
-        expect(innerHtml.indexOf("id_x_0") > 0).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") > innerHtml.indexOf("id_1")).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") > innerHtml.indexOf("id_2")).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") > innerHtml.indexOf("id_3")).to.be.true;
-        expect(innerHtml.indexOf("id_x_0") < innerHtml.indexOf("id_x_1")).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") > 0).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") > innerHtml.indexOf("id_1")).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") > innerHtml.indexOf("id_2")).to.be.true;
-        expect(innerHtml.indexOf("id_x_1") > innerHtml.indexOf("id_3")).to.be.true;
-        expect(innerHtml.indexOf("id_4") == -1).to.be.true;
-    })
     it("must have a working input handling", function () {
         DomQuery.querySelectorAll("body").innerHTML = `<form id="blarg">
     <div id="embed1">
-        <input type="text" id="id_1" name="id_1" value="id_1_val"></input>
-        <input type="text" id="id_2" name="id_2" value="id_2_val" disabled="disabled"> </input>
-        <textarea type="text" id="id_3" name="id_3">textareaVal</textarea>
+        <input type="text" id="id_1" name="id_1" value="id_1_val">
+        <input type="text" id="id_2" name="id_2" value="id_2_val" disabled="disabled">
+        <textarea id="id_3" name="id_3">textareaVal</textarea>
         <fieldset>
-            <input type="radio" id="mc" name="cc_1" value="Mastercard" checked="checked"></input>
+            <input type="radio" id="mc" name="cc_1" value="Mastercard" checked="checked">
             <label for="mc"> Mastercard</label>
-            <input type="radio" id="vi" name="cc_1" value="Visa"></input>
+            <input type="radio" id="vi" name="cc_1" value="Visa">
             <label for="vi"> Visa</label>
-            <input type="radio" id="ae" name="cc_1" value="AmericanExpress"></input>
+            <input type="radio" id="ae" name="cc_1" value="AmericanExpress">
             <label for="ae"> American Express</label>
         </fieldset>
-        <select id="val_5" name="val_5" name="top5" size="5">
+        <select id="val_5" name="val_5" size="5">
             <option>barg</option>
             <option>jjj</option>
             <option selected>akaka</option>
@@ -477,22 +375,22 @@ describe('DOMQuery tests', function () {
         let length2 = DomQuery.byId("embed1").elements.length;
         expect(length2 == 8).to.be.true;
-        let count = Stream.ofDataSource(DomQuery.byId("embed1").elements)
-            .map<number>(item => item.disabled ? 1 : 0)
+        let count = DomQuery.byId("embed1").elements
+            .stream.map(item => item.disabled ? 1 : 0)
             .reduce((val1, val2) => val1 + val2, 0);
         expect(count.value).to.eq(1);
-        Stream.ofDataSource(DomQuery.byId("embed1").elements)
-            .filter(item => item.disabled)
+        DomQuery.byId("embed1").elements
+            .stream.filter(item => item.disabled)
             .each(item => item.disabled = false);
-        count = Stream.ofDataSource(DomQuery.byId("embed1").elements)
-            .map<number>(item => item.disabled ? 1 : 0)
+        count = DomQuery.byId("embed1").elements
+            .stream.map(item => item.disabled ? 1 : 0)
             .reduce((val1, val2) => val1 + val2, 0);
         expect(count.value).to.eq(0);
-        count = Stream.ofDataSource(DomQuery.byId("embed1").elements)
-            .map<number>(item => item.attr("checked").isPresent() ? 1 : 0)
+        count = DomQuery.byId("embed1").elements
+            .stream.map(item => item.attr("checked").isPresent() ? 1 : 0)
             .reduce((val1, val2) => val1 + val2, 0);
         expect(count.value).to.eq(1);
@@ -505,7 +403,7 @@ describe('DOMQuery tests', function () {
         DomQuery.byId("id_3").inputValue.value = "hello world";
         expect(DomQuery.byId("id_3").inputValue.value).to.eq("hello world");
-        let cfg = new Config(DomQuery.querySelectorAll("form").elements.encodeFormElement());
+        let cfg = DomQuery.querySelectorAll("form").elements.encodeFormElement();
         expect(cfg.getIf("id_1").value[0]).to.eq("booga");
         expect(cfg.getIf("id_2").value[0]).to.eq("id_2_val");
         expect(cfg.getIf("id_3").value[0]).to.eq("hello world");
@@ -553,22 +451,17 @@ describe('DOMQuery tests', function () {
             //-->
             </script>
-            <style type="text/css">
+            <style>
                 #first {
                     border: 1px solid black;
                 }
             </style>
-            <link rel="stylesheet" href="./fixtures/blank.css"></link>
         `;
         let content = DomQuery.byTagName("body").runScripts().runCss();
         expect(content.byId("first").innerHTML).to.eq("hello world");
         expect(content.byId("second").innerHTML).to.eq("hello world");
         expect(content.byId("third").innerHTML).to.eq("hello world");
         expect(content.byId("fourth").innerHTML).to.eq("hello world");
-        expect(DomQuery.byTagName("head")
-            .querySelectorAll("link[rel='stylesheet'][href='./fixtures/blank.css']").length).to.eq(1);
         done();
     });
@@ -589,7 +482,7 @@ describe('DOMQuery tests', function () {
     it("it must handle events properly", function () {
         let clicked = 0;
-        let listener = (evt: any) => {
+        let listener = () => {
             clicked++;
         };
         let eventReceiver = DomQuery.byId("id_1");
@@ -605,7 +498,7 @@ describe('DOMQuery tests', function () {
     });
-    it("it must handle innerText properly", function (done) {
+    it("it must handle innerText properly", function () {
         //jsdom bug
         Object.defineProperty(Object.prototype, 'innerText', {
@@ -617,7 +510,6 @@ describe('DOMQuery tests', function () {
         let probe = DomQuery.byId("id_1");
         probe.innerHTML = "<div>hello</div><div>world</div>";
         expect(probe.innerText()).to.eq("helloworld");
-        done();
     });
     it("it must handle textContent properly", function () {
         let probe = DomQuery.byId("id_1");
@@ -627,7 +519,7 @@ describe('DOMQuery tests', function () {
     it("it must handle iterations properly", function () {
         let probe = DomQuery.byTagName("div");
-        let resArr = LazyStream.ofStreamDataSource(probe).collect(new ArrayCollector());
+        let resArr = probe.lazyStream.collect(new ArrayCollector());
         expect(resArr.length).to.eq(4);
         probe.reset();
@@ -666,21 +558,6 @@ describe('DOMQuery tests', function () {
     })
-    it("parent must break shadow barriers", function () {
-        let probe = DomQuery.fromMarkup("<div id='shadowItem'>hello</div>'");
-        try {
-            //probably not testable atm, mocha does not have shadow dom support
-            //we might be able to shim it in one way or the other
-            let element = DomQuery.byId("id_1").attachShadow();
-            element.append(probe);
-            expect(probe.firstParent("#id_1").length > 0).to.eq(true);
-        } catch (e) {
-            //not supported we still need to get an error here
-            expect(e.message.indexOf("not supported") != -1).to.be.true;
-        }
-    })
     it('it must have a working wait for dom with mut observer and must detect condition after change', async function () {
         let probe = DomQuery.byId('id_1');
         probe.innerHTML = 'true';
@@ -752,14 +629,11 @@ describe('DOMQuery tests', function () {
     it('must by recycleable', function () {
         let probe = DomQuery.querySelectorAll("div");
-        let probe2 = DomQuery.querySelectorAll("body");
         let res1 = probe.filter(item => item.matchesSelector("div"));
         expect(res1.length).to.eq(4);
         let res2 = probe.filter(item => item.matchesSelector("div"));
         expect(res2.length).to.eq(4);
     })
     it('delete must work', function () {
@@ -777,22 +651,9 @@ describe('DOMQuery tests', function () {
         let probe2 = DomQuery.querySelectorAll("div");
         let probeCnt = 0;
         let probe2Cnt = 0;
-        from(probe).subscribe(el => probeCnt++);
-        from(Stream.ofDataSource(probe2)).subscribe(el => probe2Cnt++);
+        from(probe).subscribe(() => probeCnt++);
+        from(probe2.stream).subscribe(() => probe2Cnt++);
         expect(probeCnt).to.be.above(0);
         expect(probeCnt).to.eq(probe2Cnt);
-    });
-    it('must handle closest properly', function() {
-        let probe = DomQuery.byId("id_1");
-        probe.innerHTML = "<div id='inner_elem'>hello world<div id='inner_elem2'></div></div>";
-        let probe2 = DomQuery.byId("inner_elem");
-        expect(probe2.closest("div#id_1").id.value).to.eq("id_1");
-        expect(probe2.parent().closest("div").id.value).to.eq("id_1");
-        probe2 = DomQuery.byId("inner_elem2");
-        expect(probe2.closest("div").id.value).to.eq("inner_elem2");
-        expect(probe2.closest("div#id_1").id.value).to.eq("id_1");
-        expect(probe2.parent().parent().closest("div").id.value).to.eq("id_1");
-    });
+    })
 });

package/src/main/typescript/test/frameworkBase/_ext/monadish/MonadTest.spec.ts CHANGED Viewed

@@ -125,7 +125,7 @@ describe('Config tests', () => {
     });
     it('array config2', () => {
-        let config = new Config([]);
+        let config = setup();
         config.assign("[5]", "world[3]", "from").value = "me";
         expect(config.getIf("[5]", "world[3]", "from").value).to.be.eq("me");
         expect(config.value[5].world[3].from).to.be.eq("me");
@@ -133,7 +133,7 @@ describe('Config tests', () => {
     });
     it('array config3', () => {
-        let config = new Config([]);
+        let config = setup();
         config.assign("[5]", "[3]", "from").value = "me";
         expect(config.getIf("[5]", "[3]", "from").value).to.be.eq("me");
         expect(config.value[5][3].from).to.be.eq("me");
@@ -141,7 +141,7 @@ describe('Config tests', () => {
     });
     it('array config4', () => {
-        let config = new Config([]);
+        let config = setup();
         config.assign("[5]", "[3]", "[2]").value = "me";
         expect(config.getIf("[5]", "[3]", "[2]").value).to.be.eq("me");
         expect(config.value[5][3][2]).to.be.eq("me");
@@ -149,7 +149,7 @@ describe('Config tests', () => {
     });
     it('array config5', () => {
-        let config = new Config([]);
+        let config = setup();
         config.assign("[5]", "world[3]", "from[2]").value = "me";
         expect(config.getIf("[5]", "world[3]", "from[2]").value).to.be.eq("me");
         expect(config.value[5].world[3].from[2]).to.be.eq("me");

package/src/main/typescript/test/frameworkBase/_ext/monadish/StreamTest.spec.ts ADDED Viewed

@@ -0,0 +1,231 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {describe} from "mocha";
+import {expect} from "chai";
+import {ArrayCollector, LazyStream, Stream} from "mona-dish";
+describe('early stream tests', () => {
+    beforeEach(function () {
+        this.probe = [1, 2, 3, 4, 5];
+    });
+    it("must iterate normal", function () {
+        let stream = Stream.of<number>(...this.probe);
+        let sum = 0;
+        stream.each((data) => {
+            sum = sum + data;
+        });
+        expect(sum).to.eq(15);
+        let stream2 = LazyStream.of<number>(...this.probe);
+        sum = 0;
+        stream2.each((data: number) => {
+            sum = sum + data;
+        });
+        expect(sum).to.eq(15);
+    });
+    it("must iterate filtered", function () {
+        let stream = Stream.of<number>(...this.probe);
+        let sum = 0;
+        stream.filter((data) => data != 5).each((data) => {
+            sum = sum + data;
+        });
+        expect(sum).to.eq(10);
+        let stream2 = LazyStream.of<number>(...this.probe);
+        sum = 0;
+        stream2.filter((data) => data != 5).each((data: number) => {
+            sum = sum + data;
+        });
+        expect(sum).to.eq(10);
+    });
+    it("must onElem", function () {
+        let stream = Stream.of<number>(...this.probe);
+        let sum = 0;
+        let sum2: number = stream.filter((data) => data != 5).onElem((data) => {
+            sum = sum + data;
+        }).reduce<number>((el1, el2) => el1 + el2).value;
+        expect(sum).to.eq(10);
+        expect(sum2).to.eq(10);
+        let stream2 = LazyStream.of<number>(...this.probe);
+        sum = 0;
+        sum2 = stream2.filter((data) => data != 5).onElem((data: number) => {
+            sum = sum + data;
+        }).reduce((el1: number, el2: number) => el1 + el2).value;
+        expect(sum).to.eq(10);
+        expect(sum2).to.eq(10);
+    })
+    it("must have a correct first last", function () {
+        let first = Stream.of<number>(...this.probe).filter((data) => data != 5).onElem(() => {
+        }).first().value;
+        let last = Stream.of<number>(...this.probe).filter((data) => data != 5).onElem(() => {
+        }).last().value;
+        expect(first).to.eq(1);
+        expect(last).to.eq(4);
+    });
+    it("must have a correct first last lazy", function () {
+        let first = LazyStream.of<number>(...this.probe).filter((data) => data != 5).onElem((data) => {
+            data;
+        }).first().value;
+        let last = Stream.of<number>(...this.probe).filter((data) => data != 5).onElem((data) => {
+            data;
+        }).last().value;
+        expect(first).to.eq(1);
+        expect(last).to.eq(4);
+    });
+    it("must have a correct limits", function () {
+        let cnt = 0;
+        let last = Stream.of<number>(...this.probe).filter((data) => data != 5).limits(2).onElem(() => {
+            cnt++;
+        }).last().value;
+        expect(last).to.eq(2);
+        expect(cnt).to.eq(2);
+    });
+    it("must initialize correctly from assoc array", function () {
+        let probe = {
+            key1: "val1",
+            key2: 2,
+            key3: "val3"
+        }
+        let arr1: Array<string | number> = [];
+        let arr2: Array<string | number> = [];
+        Stream.ofAssoc(probe).each(item => {
+            expect(item.length).to.eq(2);
+            arr1.push(item[0]);
+            arr2.push(item[1]);
+        });
+        expect(arr1.join(",")).to.eq("key1,key2,key3");
+        expect(arr2.join(",")).to.eq("val1,2,val3");
+    });
+    it("must have a correct lazy limits", function () {
+        let last = LazyStream.of<number>(...this.probe).filter((data) => data != 5).limits(2).onElem((data) => {
+            data;
+        }).last().value;
+        expect(last).to.eq(2);
+    })
+    it("must correctly lazily flatmap", function () {
+        let resultingArr = LazyStream.of<number>(...this.probe).flatMap((data) => LazyStream.of(...[data, 2])).value;
+        expect(resultingArr.length == 10).to.be.true;
+        expect(resultingArr.join(",")).to.eq("1,2,2,2,3,2,4,2,5,2");
+    });
+    it("must correctly lazily flatmap with arrays", function () {
+        let resultingArr = LazyStream.of<number>(...this.probe).flatMap((data) => [data, 2]).value;
+        expect(resultingArr.length == 10).to.be.true;
+        expect(resultingArr.join(",")).to.eq("1,2,2,2,3,2,4,2,5,2");
+    });
+    it("must correctly early flatmap", function () {
+        let resultingArr = Stream.of<number>(...this.probe).flatMap((data) => Stream.of(...[data, 2])).value;
+        expect(resultingArr.length == 10).to.be.true;
+        expect(resultingArr.join(",")).to.eq("1,2,2,2,3,2,4,2,5,2");
+    });
+    it("must correctly early flatmap with arrays", function () {
+        let resultingArr = Stream.of<number>(...this.probe).flatMap((data) => [data, 2]).value;
+        expect(resultingArr.length == 10).to.be.true;
+        expect(resultingArr.join(",")).to.eq("1,2,2,2,3,2,4,2,5,2");
+    });
+    it("must correctly flatmap intermixed", function () {
+        let resultingArr = LazyStream.of<number>(...this.probe).flatMap((data) => Stream.of(...[data, 2])).value;
+        expect(resultingArr.length == 10).to.be.true;
+        expect(resultingArr.join(",")).to.eq("1,2,2,2,3,2,4,2,5,2");
+    });
+    it("must correctly flatmap intermixed2", function () {
+        let resultingArr = Stream.of<number>(...this.probe).flatMap((data) => LazyStream.of(...[data, 2])).value;
+        expect(resultingArr.length == 10).to.be.true;
+        expect(resultingArr.join(",")).to.eq("1,2,2,2,3,2,4,2,5,2");
+    });
+    it("must correctly pass anyMatch allMatch noneMatch", function () {
+        let anyMatch = LazyStream.of<number>(...this.probe).anyMatch((item) => item == 3);
+        let allMatch = LazyStream.of<number>(...this.probe).allMatch((item) => item < 6);
+        let noneMatch = LazyStream.of<number>(...this.probe).noneMatch((item) => item > 5);
+        expect(anyMatch).to.be.true;
+        expect(allMatch).to.be.true;
+        expect(noneMatch).to.be.true;
+    })
+    it("must correctly pass anyMatch allMatch noneMatch early", function () {
+        let anyMatch = Stream.of<number>(...this.probe).anyMatch((item) => item == 3);
+        let allMatch = Stream.of<number>(...this.probe).allMatch((item) => item < 6);
+        let noneMatch = Stream.of<number>(...this.probe).noneMatch((item) => item > 5);
+        expect(anyMatch).to.be.true;
+        expect(allMatch).to.be.true;
+        expect(noneMatch).to.be.true;
+    })
+    it("must sort correctly", function () {
+        let probe: Array<number> = [1, 5, 3, 2, 4];
+        let res = Stream.of<number>(...probe)
+            .sort((el1: number, el2: number) => el1 - el2)
+            .collect(new ArrayCollector());
+        expect(res.join(",")).to.eq("1,2,3,4,5");
+    })
+    it("must sort correctly lazy", function () {
+        let probe: Array<number> = [1, 5, 3, 2, 4];
+        let res = LazyStream.of<number>(...probe)
+            .sort((el1: number, el2: number) => el1 - el2)
+            .collect(new ArrayCollector());
+        expect(res.join(",")).to.eq("1,2,3,4,5");
+    })
+});