= Test Suite: _c Starting Mem at 44k total/maxIdx=11/11 page-size=4096b == Basic Features === Testing: Core Initializing core system tests - PASS Test that a test can run - PASS Test that the STR_MAX is less than a MemPage with 5 expansions span slabs Mem 44k total/maxIdx=11/12 page-size=4096b === Testing: MemCh Tests Testing the underlying memory manager to ensure leaks have not occured in specific cases.. - PASS MemBook chapters match the start level Mem 44k total/maxIdx=11/25 page-size=4096b === Testing: MemCh Level Tests Testing adding a remove memory on levels of a Memory Chapter - PASS MemBook chapters match the start level Mem 44k total/maxIdx=11/25 page-size=4096b === Testing: Span Span is the basic data structure for sequential or logorithmic storage access. - PASS Retrieved item is not null 0 - PASS Retrieve an object with the same value as the index 0 vs 0 - PASS Retrieved item is not null 1 - PASS Retrieve an object with the same value as the index 1 vs 1 - PASS Retrieved item is not null 2 - PASS Retrieve an object with the same value as the index 2 vs 2 - PASS Retrieved item is not null 3 - PASS Retrieve an object with the same value as the index 3 vs 3 - PASS Retrieved item is not null 4 - PASS Retrieve an object with the same value as the index 4 vs 4 - PASS Retrieved item is not null 5 - PASS Retrieve an object with the same value as the index 5 vs 5 - PASS Retrieved item is not null 0 - PASS Retrieve an object with the same value as the index 0 vs 0 - PASS Retrieved item is not null 1 - PASS Retrieve an object with the same value as the index 1 vs 1 - PASS Retrieved item is not null 2 - PASS Retrieve an object with the same value as the index 2 vs 2 - PASS Retrieved item is not null 3 - PASS Retrieve an object with the same value as the index 3 vs 3 - PASS Retrieved item is not null 4 - PASS Retrieve an object with the same value as the index 4 vs 4 - PASS Retrieved item is not null 5 - PASS Retrieve an object with the same value as the index 5 vs 5 - PASS Retrieved item is not null 6 - PASS Retrieve an object with the same value as the index 6 vs 6 - PASS Retrieved item is not null 7 - PASS Retrieve an object with the same value as the index 7 vs 7 - PASS Retrieved item is not null 8 - PASS Retrieve an object with the same value as the index 8 vs 8 - PASS Retrieved item is not null 9 - PASS Retrieve an object with the same value as the index 9 vs 9 - PASS Retrieved item is not null 10 - PASS Retrieve an object with the same value as the index 10 vs 10 - PASS Retrieved item is not null 11 - PASS Retrieve an object with the same value as the index 11 vs 11 - PASS Retrieved item is not null 12 - PASS Retrieve an object with the same value as the index 12 vs 12 - PASS Retrieved item is not null 13 - PASS Retrieve an object with the same value as the index 13 vs 13 - PASS Retrieved item is not null 14 - PASS Retrieve an object with the same value as the index 14 vs 14 - PASS Retrieved item is not null 15 - PASS Retrieve an object with the same value as the index 15 vs 15 - PASS Retrieved item is not null 16 - PASS Retrieve an object with the same value as the index 16 vs 16 - PASS Span has type span 'TYPE_SPAN' found 'TYPE_SPAN' - PASS Span item 0 has type string TYPE_STR found TYPE_STR - PASS String 1 equals Hello there found Hello there - PASS Span item 2 has type string TYPE_STR found TYPE_STR - PASS String 3 equals 'Three' found 'Three' - PASS Span item 6 has type string 'TYPE_STR' found 'TYPE_STR' - PASS String 7 equals 'Seven' found 'Seven' - PASS Span item 7 has type string TYPE_STR found TYPE_STR - PASS String 8 equals 'Eight' found 'Eight' - PASS After expand, Span item 0 is not null - PASS After expand, Span item 0 has type string TYPE_STR found TYPE_STR - PASS String 1 equals 'Hello there' found 'Hello there' - PASS After expand,Span item 2 has type string "TYPE_STR" found "TYPE_STR" - PASS String 3 equals 'Three' found 'Three' - PASS After expand,Span item 6 has type string TYPE_STR found TYPE_STR - PASS String 7 equals 'Seven' found 'Seven' - PASS After expand, Span item 7 has type string TYPE_STR found TYPE_STR - PASS String 8 equals 'TYPE_STR' found 'TYPE_STR' - PASS Span item 512 has type string TYPE_STR found TYPE_STR - PASS String 512 equals "Five Twelve" found "Five Twelve" - PASS Span item 4079 has type string TYPE_STR found TYPE_STR - PASS String 4079 equals "Four Hundred Seventy Nine" found "Four Hundred Seventy Nine" - PASS Span item 513 has type string TYPE_STR found TYPE_STR - PASS String 513 equals "Five Thirteen" found "Five Thirteen" Mem 56k total/maxIdx=14/25 page-size=4096b === Testing: Iter Iter tests for iteration and insertion. - PASS Iter_Next first set of values gives expected, expected "FancyOne", have "FancyOne" - PASS Iter_Next first set of values gives expected, expected "FancyTwoA", have "FancyTwoA" - PASS Iter_Next first set of values gives expected, expected "FancyThreeA", have "FancyThreeA" - PASS Iter_Next first set of values gives expected, expected "FancyFour", have "FancyFour" - PASS Iter_Next second set of values gives expected, expected "FancyOne", have "FancyOne" - PASS Iter_Next second set of values gives expected, expected "FancyTwoA", have "FancyTwoA" - PASS Iter_Next second set of values gives expected, expected "FancyThreeA", have "FancyThreeA" - PASS Iter_Next second set of values gives expected, expected "FancyThreeB", have "FancyThreeB" - PASS Iter_Next second set of values gives expected, expected "FancyFour", have "FancyFour" - PASS Iter_Next third set of values gives expected, expected "FancyOne", have "FancyOne" - PASS Iter_Next third set of values gives expected, expected "FancyTwoA", have "FancyTwoA" - PASS Iter_Next third set of values gives expected, expected "FancyTwoB", have "FancyTwoB" - PASS Iter_Next third set of values gives expected, expected "FancyThreeA", have "FancyThreeA" - PASS Iter_Next third set of values gives expected, expected "FancyThreeB", have "FancyThreeB" - PASS Iter_Next third set of values gives expected, expected "FancyFour", have "FancyFour" - PASS Iter_Next fourth set of values gives expected, expected "FancyOne", have "FancyOne" - PASS Iter_Next fourth set of values gives expected, expected "FancyTwoA", have "FancyTwoA" - PASS Iter_Next fourth set of values gives expected, expected "FancyThreeA", have "FancyThreeA" - PASS Iter_Next fourth set of values gives expected, expected "FancyFour", have "FancyFour" - PASS Iter_Next fourth set of values gives expected, expected "FancyFive", have "FancyFive" - PASS Iter_Next fourth set of values gives expected, expected "FancySix", have "FancySix" - PASS Iter_Next fourth set of values gives expected, expected "FancySixTwo", have "FancySixTwo" - PASS Iter_Next fourth set of values gives expected, expected "FancySeven", have "FancySeven" - PASS Iter_Next fourth set of values gives expected, expected "FancyEight", have "FancyEight" - PASS Iter_Next fourth set of values gives expected, expected "FancyNine", have "FancyNine" - PASS Iter_Next fourth set of values gives expected, expected "FancyTen", have "FancyTen" - PASS Iter_Next fourth set of values gives expected, expected "FancyEleven", have "FancyEleven" - PASS Iter_Next fourth set of values gives expected, expected "FancyTwelve", have "FancyTwelve" - PASS Iter_Next fourth set of values gives expected, expected "FancyThirteen", have "FancyThirteen" - PASS Iter_Next fourth set of values gives expected, expected "FancyFourteen", have "FancyFourteen" - PASS Iter_Next fourth set of values gives expected, expected "FancyFifteen", have "FancyFifteen" - PASS Iter_Next fourth set of values gives expected, expected "FancySixteen", have "FancySixteen" - PASS Iter_Next fourth set of values gives expected, expected "FancySeventeen", have "FancySeventeen" - PASS Iter_Next fourth set of values gives expected, expected "FancyEighteen", have "FancyEighteen" - PASS 177 Was added in the middle of 5k values, ended contigous values expected 5128, have 5128 - PASS Iter_Prev set of values gives expected, expected "FancyEighteen", have "FancyEighteen" - PASS Iter_Prev set of values gives expected, expected "FancySeventeen", have "FancySeventeen" - PASS Iter_Prev set of values gives expected, expected "FancySixteen", have "FancySixteen" - PASS Iter_Prev set of values gives expected, expected "FancyFifteen", have "FancyFifteen" - PASS Iter_Prev set of values gives expected, expected "FancyFourteen", have "FancyFourteen" - PASS Iter_Prev set of values gives expected, expected "FancyThirteen", have "FancyThirteen" - PASS Iter_Prev set of values gives expected, expected "FancyTwelve", have "FancyTwelve" - PASS Iter_Prev set of values gives expected, expected "FancyEleven", have "FancyEleven" - PASS Iter_Prev set of values gives expected, expected "FancyTen", have "FancyTen" - PASS Iter_Prev set of values gives expected, expected "FancyNine", have "FancyNine" - PASS Iter_Prev set of values gives expected, expected "FancyEight", have "FancyEight" - PASS Iter_Prev set of values gives expected, expected "FancySeven", have "FancySeven" - PASS Iter_Prev set of values gives expected, expected "FancySixTwo", have "FancySixTwo" - PASS Iter_Prev set of values gives expected, expected "FancySix", have "FancySix" - PASS Iter_Prev set of values gives expected, expected "FancyFive", have "FancyFive" - PASS Iter_Prev set of values gives expected, expected "FancyFour", have "FancyFour" - PASS Iter_Prev set of values gives expected, expected "FancyThreeA", have "FancyThreeA" - PASS Iter_Prev set of values gives expected, expected "FancyTwoA", have "FancyTwoA" - PASS Iter_Prev set of values gives expected, expected "FancyOne", have "FancyOne" - PASS Iter_Prev ends at first value, expected "FancyOne", have "FancyOne" Mem 88k total/maxIdx=22/35 page-size=4096b === Testing: Str Tests for the basic string object and convienience features - PASS Expect string to have fixed type TYPE_STR found "Hi" - PASS Expect string length of 2 found 2 - PASS Expect string match of "Hi" found "Hi" - PASS Expect for i32 value 35072 length of 5 found 5 - PASS Expect string match of i32 of 35072 to string - PASS Expect length 271, have 271 Mem 92k total/maxIdx=23/35 page-size=4096b === Testing: StrVec Testing String Vectors - PASS Testing StrVec and Str 'hi dude, what a wild ride!' vs 'hi dude, what a wild ride!' - PASS Testing ReAligned StrVec and Str 'hi dude, what a wild ride!' vs 'hi dude, what a wild ride!' Mem 92k total/maxIdx=23/35 page-size=4096b === Testing: String - End Matches Tests for Matching the end of the string - PASS file ending in '.c' matches successfully, had "file1.c" - PASS file ending in '.cnk' matches successfully, had "file1.cnk" - PASS file ending in '.cnk' matches ".c" after String_Trunc successfully, had "file1.c" Mem 92k total/maxIdx=23/35 page-size=4096b === Testing: Buff Tests Testing the buffer add functionality. - PASS Content is expected in StrVec of Buff - PASS Content with a long additional is expected in StrVec of Buff Mem 92k total/maxIdx=23/35 page-size=4096b === Testing: Buff Send/Recv Tests Testing the buffer send and recv components. - PASS Content is expected in StrVec of Buff, expected "All of the things you want to know are kindof like dandilions.", have [All of the things you want to know are kindof like dandilions.] - PASS Content with a long additional is expected in StrVec of Buff - PASS Buff_GetStr has populated an equal StrVec Mem 92k total/maxIdx=23/35 page-size=4096b === Testing: Buff IO Tests Testing the buffer send and recv to disk/socket components. - PASS File opened successfully to create and write have 4fd for [/,basic,/,caneka-checkout,/,examples,/,test,/,buffio,.,txt] - PASS Buff total is still 0 after sending content through it unbuffered: Buff<[SUCCESS,FD,UNBUFFERED] -1fd unsent/total=0/0> - PASS File opened successfully to after write, have 4fd for [/,basic,/,caneka-checkout,/,examples,/,test,/,buffio,.,txt] - PASS Second file opened successfully to create and write have 5fd for [/,basic,/,caneka-checkout,/,examples,/,test,/,buffio-compare,.,txt] - PASS Second file opened successfully to create for reading have 4fd for [/,basic,/,caneka-checkout,/,examples,/,test,/,buffio-compare,.,txt] - PASS File opened successfully to after write, have 4fd for [/,basic,/,caneka-checkout,/,examples,/,test,/,buffio-compare,.,txt] - PASS After writing, reading, writing somewhere else, and then reading it again, it all equals, expected "Hidy Ho, my friend, this is a nice place to be. where things are peachy and wonderous. Yay woundersous is as good a word as walrus. If you're reading this, then something is probably broken, and your looking at the test. I'm so sorry it's broken. But we believe you can fix it. Yay.", have [Hidy Ho, my friend, this is a nice place to be. where things are peachy and wonderous. Yay woundersous is as good a word as walrus. If you're reading this, then something is probably broken, and your looking at the test. I'm so sorry it's broken. But we believe you can fix it. Yay.] - PASS Remove file [/,basic,/,caneka-checkout,/,examples,/,test,/,buffio,.,txt] - PASS Remove file [/,basic,/,caneka-checkout,/,examples,/,test,/,buffio-compare,.,txt] Mem 96k total/maxIdx=24/35 page-size=4096b === Testing: Buff Position Tests Testing the buffer position features of seeking and moving around it. - PASS Buff: Expected position and unset Buff<[ZERO/READY] -1fd unsent/total=67/67> - PASS Buff +10: Expected position and unset Buff<[ZERO/READY] -1fd unsent/total=57/67> - PASS Buff -10(abs): Expected position and unset Buff<[ZERO/READY] -1fd unsent/total=10/67> - PASS Buff -20: Expected position and unset Buff<[ZERO/READY] -1fd unsent/total=30/67> - PASS Buff +3: Expected position and unset Buff<[ZERO/READY] -1fd unsent/total=27/67> - PASS Buff 7(abs): Expected position and unset Buff<[ZERO/READY] -1fd unsent/total=60/67> Mem 100k total/maxIdx=25/35 page-size=4096b === Testing: Buff Stream Tests Testing setting up and running multiple stream types and stream chains - PASS Comparing StrVec built up slowly, and one built all at once Mem 100k total/maxIdx=25/35 page-size=4096b === Testing: Cursor Tests Cursor tests for adding and navigation the position of a StrVec - PASS Ptr is not NULL - PASS Stops on the first 'n' for and - PASS Stops on the second character of the second string in the Cursor's StrVec - PASS Stops on the 'y' for sky - PASS Stops on the 32nd y in sky of the same, second Cursor's StrVec, have 31 - PASS Stops on the 'F' for For - PASS Stops on the 2nd character of the third Cursor's StrVec, have 1 - PASS Stops on the 's' for sky - PASS Stops on the 29th character of the third Cursor's StrVec, have 29 Mem 100k total/maxIdx=25/35 page-size=4096b === Testing: DebugStack Tests Testing DebugStack crash debugging system - PASS Stack printout has less characters than before Mem 100k total/maxIdx=25/35 page-size=4096b === Testing: Hash Tests for the Hash object which used for table storage and comparison of a few Polymorphic data types. - PASS Expected hash to equal 1001101111001011100010100000011000011011011111110011000111011100/4291084750259606489, found: 1001101111001011100010100000011000011011011111110011000111011100/4291084750259606489 Mem 100k total/maxIdx=25/35 page-size=4096b === Testing: Table HKey Tests Testing table HKey component which determines the order of indicies to look for an item. - PASS Test idx mismatch for expected 13, have 13, of HKey - PASS Test idx mismatch for expected 41, have 41, of HKey - PASS Test idx mismatch for expected 87, have 87, of HKey - PASS Test idx mismatch for expected 112, have 112, of HKey - PASS Test idx mismatch for expected 13, have 13, of HKey - PASS Test idx mismatch for expected 0, have 0, of HKey - PASS Test idx mismatch for expected 9, have 9, of HKey - PASS Test idx mismatch for expected 2, have 2, of HKey - PASS Test idx mismatch for expected 3, have 3, of HKey - PASS Test idx mismatch for expected 4, have 4, of HKey - PASS Test idx mismatch for expected 5, have 5, of HKey - PASS Test idx mismatch for expected 6, have 6, of HKey Mem 112k total/maxIdx=28/35 page-size=4096b === Testing: Table Auto-scaling hash-table built on top of the Span object and Hash object. - PASS Expect strings to not be NULL from key:"Alpha" - PASS Expect strings to equal "Apples" from key:"Alpha" found "Apples" - PASS Expect strings to not be NULL from key:"Bravo" - PASS Expect strings to equal "Bandits" from key:"Bravo" found "Bandits" - PASS Expect strings to not be NULL from key:"Charlie" - PASS Expect strings to equal "Carrots" from key:"Charlie" found "Carrots" - PASS Expect strings to not be NULL from key:"Delta" - PASS Expect strings to equal "DeadMan" from key:"Delta" found "DeadMan" - PASS Expect strings to not be NULL from key:"Echo" - PASS Expect strings to equal "Elevator" from key:"Echo" found "Elevator" - PASS Expect strings to not be NULL from key:"Foxtrot" - PASS Expect strings to equal "Five Minutes" from key:"Foxtrot" found "Five Minutes" - PASS Expect strings to not be NULL from key:"Golf" - PASS Expect strings to equal "Gophers Are Cool" from key:"Golf" found "Gophers Are Cool" Mem 120k total/maxIdx=30/35 page-size=4096b === Testing: TableResize Resize features of the auto-scaling hash-table. - PASS Expect strings to not be NULL from key:Alpha - PASS Expect strings to equal Apples from key:"Alpha" found "Apples" - PASS Expect strings to not be NULL from key:Bravo - PASS Expect strings to equal Bandits from key:"Bravo" found "Bandits" - PASS Expect strings to not be NULL from key:Charlie - PASS Expect strings to equal Carrots from key:"Charlie" found "Carrots" - PASS Expect strings to not be NULL from key:Delta - PASS Expect strings to equal DeadMan from key:"Delta" found "DeadMan" - PASS Expect strings to not be NULL from key:Echo - PASS Expect strings to equal Elevator from key:"Echo" found "Elevator" - PASS Expect strings to not be NULL from key:Foxtrot - PASS Expect strings to equal Five Minutes from key:"Foxtrot" found "Five Minutes" - PASS Expect strings to not be NULL from key:Golf - PASS Expect strings to equal Gophers Are Cool from key:"Golf" found "Gophers Are Cool" - PASS Expect strings to not be NULL from key:Hotel - PASS Expect strings to equal Happy Go Lucky from key:"Hotel" found "Happy Go Lucky" - PASS Expect strings to not be NULL from key:India - PASS Expect strings to equal Idio-syncratic from key:"India" found "Idio-syncratic" - PASS Expect strings to not be NULL from key:Juliet - PASS Expect strings to equal Jockey Rider from key:"Juliet" found "Jockey Rider" - PASS Expect strings to not be NULL from key:Kilo - PASS Expect strings to equal Kangaroo from key:"Kilo" found "Kangaroo" - PASS Expect strings to not be NULL from key:Lima - PASS Expect strings to equal Lefties from key:"Lima" found "Lefties" - PASS Expect strings to not be NULL from key:Mike - PASS Expect strings to equal Mangoes from key:"Mike" found "Mangoes" - PASS Expect strings to not be NULL from key:November - PASS Expect strings to equal Neighbourhood Villan from key:"November" found "Neighbourhood Villan" - PASS Expect strings to not be NULL from key:Oscar - PASS Expect strings to equal Oasis of Gems from key:"Oscar" found "Oasis of Gems" - PASS Expect strings to not be NULL from key:Pappa - PASS Expect strings to equal Pinapple Ham from key:"Pappa" found "Pinapple Ham" - PASS Expect strings to not be NULL from key:Quebec - PASS Expect strings to equal Quarterly Report from key:"Quebec" found "Quarterly Report" - PASS Expect strings to not be NULL from key:Romeo - PASS Expect strings to equal Rooty Tooty from key:"Romeo" found "Rooty Tooty" - PASS Expect strings to not be NULL from key:Sierra - PASS Expect strings to equal Stainless Steel from key:"Sierra" found "Stainless Steel" Mem 132k total/maxIdx=33/35 page-size=4096b === Testing: TableUtilKey Testing table with a util wrapped instead of string keys. - PASS Expected 10 items to be added Mem 132k total/maxIdx=33/35 page-size=4096b === Testing: Clone Clone test of cloning basic types. - PASS Str clone is equal, expected "fancy things" have "fancy things" - PASS Span clone is equal, expected [31,"boo bah bing bang!","hi","there",13,27] have [31,"boo bah bing bang!","hi","there",13,27] - PASS StrVec clone is equal, expected [And the end is naer, but we will have a hopping good time anyway! yay!] have [And the end is naer, but we will have a hopping good time anyway! yay!] Mem 140k total/maxIdx=35/35 page-size=4096b === Testing: Time Time tests for converstion between unix syscalls and microTime. - PASS Time equates to four hours and 2k microseconds after January 1st 1970, have 1970-01-01T04:00:00.2+00 Mem 140k total/maxIdx=35/36 page-size=4096b === Testing: Object Tests Object tests of ordered table of add/get. - PASS Hashed found for H<13 "One" -> 1>/One - PASS Object data lines up with expectations of ordIdx 0, key "One", value, 1, have H<0,13 5595300432710310669/"One" -> Wptr<_TYPE_ZERO <*0/35/3968>>/TYPE_WRAPPED_I8> - PASS Hashed found for H<11 "Two" -> 2>/Two - PASS Object data lines up with expectations of ordIdx 1, key "Two", value, 2, have H<1,11 -5149713540703021141/"Two" -> Wptr<_TYPE_ZERO <*0/35/3896>>/TYPE_WRAPPED_I8> - PASS Hashed found for H<9 "Three" -> 3>/Three - PASS Object data lines up with expectations of ordIdx 2, key "Three", value, 3, have H<2,9 8215423831064988601/"Three" -> Wptr<_TYPE_ZERO <*0/35/3824>>/TYPE_WRAPPED_I8> Mem 148k total/maxIdx=37/38 page-size=4096b === Testing: Object Filter Tests Object filter tests. Mem 148k total/maxIdx=37/38 page-size=4096b == Persistance Tests === Testing: Path Tests Testing path functions for file and object variable paths. - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS Expected length to equal expected for Str - PASS Expected content to equal expected for Str - PASS Expected flags to equal expected for Str - PASS base path is extracted properly - PASS file name is extracted properly Mem 160k total/maxIdx=40/41 page-size=4096b === Testing: Stash Tests Mem Stash testing. - PASS Pointer has been mutated and packed - PASS Coord has type of object - PASS Coord has idx sent to PackAddr - PASS Coord has been restored expected 0000001001100001011001011011001001001110111111100000000000000000, have 0000001001100001011001011011001001001110111111100000000000000000 - PASS Bytes written equals 1 page + StashHeader, expected 4100, have 4100 - Buff<[SUCCESS,END,FD] 4fd unsent/total=0/4100> - PASS Stash From Stream returns non-null - PASS loaded is not the original - PASS Str is not the original - PASS Str has equivilent value, expected Str, have Str Mem 168k total/maxIdx=42/50 page-size=4096b === Testing: BinSeg Tests Transactional format encoding capable of representing stream, node, and database content. - PASS Ctx finished with status SUCCESS|END - PASS first value is expected - PASS second value is expected Mem 168k total/maxIdx=42/50 page-size=4096b === Testing: BinSegCollection Tests Transactional format storing and reading collection and dictionary data types. - PASS Object Fmt parsed with status without ERROR - PASS Ctx finished with status SUCCESS|END - PASS first value is expected - PASS second value is expected - PASS third value is expected - PASS keyC value is equal, expected "Casualty", have Str - PASS keyD value is equal, expected "Delaware", have Str - PASS key3 StrVec value is equal, expected [one+two+three+four], have [one,+,two,+,three,+,four] Mem 168k total/maxIdx=42/65 page-size=4096b === Testing: BinSegV Tests Transactional format only encoded in visible hex format characters. - PASS Ctx finished with status SUCCESS|END - PASS first value is expected - PASS second value is expected - PASS third value is expected - PASS keyC value is equal, expected "Casualty", have Str - PASS keyD value is equal, expected "Delaware", have Str Mem 172k total/maxIdx=43/65 page-size=4096b === Testing: BinSegReversedV Tests Transactional format reversed and only encoded in visible hex format characters. - PASS Ctx finished with status SUCCESS|END - PASS first value is expected - PASS second value is expected - PASS third value is expected - PASS keyC value is equal, expected "Casualty", have Str - PASS keyD value is equal, expected "Delaware", have Str Mem 172k total/maxIdx=43/65 page-size=4096b === Testing: FileDB Tests FileD database built on BinSegRV tests of how to save and retrive data. - PASS Latest ID has been set for one record - PASS Found name from table, exected "Sam-Iam-ICan", have "Sam-Iam-ICan" - PASS Found name from table, exected "Sam-Iam-ICan", have "Sam-Iam-ICan" - PASS Found pw from table, exected "hI90_jfiu#ud92j$_22uj", have "hI90_jfiu#ud92j$_22uj" - PASS Found email from table, exected "puppies@example.com", have "puppies@example.com" - PASS Found new pw from table, exected "ruiwoiuer878923jkolwer_#2j", have "ruiwoiuer878923jkolwer_#2j" Mem 176k total/maxIdx=44/65 page-size=4096b == Roebling Parser === Testing: Pattern Character Tests Making patterns from strings. - PASS PatChar basic pattern matches Pat vs Pat - PASS PatChar ko pattern matches Pat vs Pat - PASS PatChar long vec pattern matches Pat vs Pat Mem 180k total/maxIdx=45/65 page-size=4096b === Testing: Match Tests Matching various patterns. - PASS Non match has unsuccessful state found "NOOP" - PASS Matching string has successful state found [SUCCESS] - PASS Matched length of string, less termMatching, expected 14 have 14 Mem 180k total/maxIdx=45/65 page-size=4096b === Testing: Match Elastic Tests Testing matches on ranges that have variable or elastic lengths. - PASS Has PROCESSING status PROCESSINGCLS_FLAG_ALPHA - PASS On second pos, position is 1 - PASS Tag -Stopped on the fourth character - PASS Tag -Found three chars - PASS Tag- Found SUCCESS have "SUCCESSCLS_FLAG_CHARLIE" - PASS Tag -At end - PASS Att - Found 4 chars, count is Wi64<4> Mem 184k total/maxIdx=46/65 page-size=4096b === Testing: Match Knockout Tests Testing knockout patterns in match definitions. - PASS Length matches for string that has no escape or closing quote 25 - PASS Length matches for string minus escape cahrs that has two escapes in it, expecting 34, have 36 - PASS Length matches for string that has a terminator quote in it, have 33 - PASS Length matches for string that has a escaped terminator quote in it, have 40 - PASS It took 10 counts to get to the end, have 9 - PASS Terminator 'end' is omited from the count expecting 7, have 7 - PASS terminator 'end' is omited and last punctuation as well, from the count, expecting 32, have 32 - PASS counted first letter only, have 1 Mem 184k total/maxIdx=46/65 page-size=4096b === Testing: Match Replace Tests Tests for Str replaces with Match - PASS Match Mt SNIP_CONTENT/0>: Replacing Str with Str in /happy/sad/fancy/things to make Str - PASS Match Mt SNIP_CONTENT/0>: Replacing "sad" with "it" in /happy/sad/fancy/things to make Str Mem 188k total/maxIdx=47/65 page-size=4096b === Testing: StrVecSplit via Match Testing String Vector Split function - PASS Split by [StrVec,1: Str,2: Str,3: Str,4: Str,5: Str,6: Str]>] "." becomes ["this","that","thingy","x"]. - PASS Split by [StrVec,1: Str,2: Str,3: Str,4: Str,5: Str,6: Str]>] Mt SNIP_SKIPPED/1> becomes ["this","that","thingy","x"]. - PASS Split by [StrVec,1: Str,2: Str,3: Str,4: Str,5: Str,6: Str]>] 46 becomes ["this","that","thingy","x"]. Mem 216k total/maxIdx=54/65 page-size=4096b === Testing: Snip Tests Snip tests for capturing a segment of a cursor - PASS Found expected keyword "sunshine", have [sunshine] from Sns of [Rain ,and sunshine, and clouds and sky.] Mem 216k total/maxIdx=54/65 page-size=4096b === Testing: Snip Modify Tests Snip tests for modifying an existing captur in progress - PASS Start of line matches, expected [StrVec]>], have Str - PASS SnipSpan now has single value which is a gap that spans the total length, have Sns> Mem 220k total/maxIdx=55/65 page-size=4096b === Testing: Roebling Init Test Roebling tests for adding and running a basic parser. - PASS Roebling has four match values loaded up, have 4 Mem 220k total/maxIdx=55/65 page-size=4096b === Testing: Roebling Run Tests Roebling basic run tests. - PASS Roebling has state ROEBLING-NEXT - PASS Content equals expected '"TWO"', have [TWO] - PASS Match Idx equals expected, have -1 - PASS Roebling has captured the rest of the line, expected 'for the weekend', have '[for the weekend]' - PASS Roebling has state ROEBLING-NEXT Mem 220k total/maxIdx=55/65 page-size=4096b === Testing: Roebling Mark Tests Roebling mark tests. - PASS Content equals TWO, have [TWO] - PASS Roebling has state ROEBLING_NEXT after 'TWO' - PASS Roebling has captured the rest of the line: [for the weekend] - PASS Roebling has state ROEBLING_NEXT after 'for the weekend' - PASS Content equals ONE, have [ONE] - PASS Roebling has state ROEBLING_NEXT after 'ONE' - PASS Roebling has captured the rest of the line: [for good measure] - PASS Roebling has state ROEBLING_NEXT - PASS Content equals THREE, have [THREE] - PASS Roebling has state ROEBLING_NEXT - PASS Roebling has captured the rest of the line: [for all!] - PASS Roebling has state ROEBLING_NEXT - PASS Roebling has state SUCCESS, have SUCCESS Mem 220k total/maxIdx=55/65 page-size=4096b === Testing: Roebling Start Stop Tests Roebling start and stop in the middle of recieving input tests. - PASS String equals 'Hi how are you today?', have '[Hi how are you today?]' for Rbl Mt ZERO/READY/0>> Mem 224k total/maxIdx=56/65 page-size=4096b == Formats === Testing: Mess Tests From a basic Fmt Roebling parser into the Mess data structures. - PASS Mess has been built as expected Mem 224k total/maxIdx=56/93 page-size=4096b === Testing: FmtHtml Tests Format FMT -> HTML tests. - PASS Fmt to HTML has status SUCCESS - PASS Fmt to HTML has expected html content Mem 224k total/maxIdx=56/101 page-size=4096b === Testing: NodeObj Tests Node Object nested path tests. - PASS Children table has been automatically populated - PASS After setting and requesting ByPath NodeObjs match and has expected property [/,one] -> name:"one" -> NodeObj<[ZERO/READY]#"children": {}, #"atts": {}, #"name": [one]> - PASS After setting and requesting ByPath NodeObjs match and has expected property [/,two] -> name:"two" -> NodeObj<[ZERO/READY]#"children": {}, #"atts": {}, #"name": [two]> - PASS After setting and requesting ByPath NodeObjs match and has expected property [/,three] -> name:"three" -> NodeObj<[ZERO/READY]#"children": {}, #"atts": {}, #"name": [three]> - PASS After setting and requesting ByPath NodeObjs match and has expected property [/,four] -> name:"four" -> NodeObj<[ZERO/READY]#"children": {}, #"atts": {}, #"name": [four]> - PASS After setting and requesting ByPath NodeObjs match and has expected property [/,two,/,secondary,/,stuff-two] -> name:"two-nested" -> NodeObj<[ZERO/READY]#"children": {}, #"atts": {}, #"name": [two-nested]> - PASS After setting and requesting ByPath NodeObjs match and has expected property [/,six,/,new-root,/,stuff-three] -> name:"fresh-three" -> NodeObj<[ZERO/READY]#"children": {}, #"atts": {}, #"name": [fresh-three]> - PASS After setting and requesting ByPath NodeObjs match and has expected property [/,two,/,and,/,nested,/,stuff-one] -> name:"two-nested-one" -> NodeObj<[ZERO/READY]#"children": {}, #"atts": {}, #"name": [two-nested-one]> - PASS Missing path should be NULL Mem 236k total/maxIdx=59/101 page-size=4096b === Testing: Config Tests Config tests that turn a basic configuration format into an object - PASS Doc node is not NULL: [doc] -> NodeObj<[ZERO/READY]#"children": {0={"list"=[[one],[two],[three]]},"footer"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"content"=[A secondary view of things.]}, #"name": [footer]>,"tag"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"att-two"=[two],"att-one"=[one]}, #"name": [tag]>}, #"atts": {"alpha"=[apple],"bravo"=[bannanna],"charlie"=[carrot],"start"=Wi64<3>}, #"name": [doc]> - PASS NodeObj NodeObj<[ZERO/READY]#"children": {0={"list"=[[one],[two],[three]]},"footer"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"content"=[A secondary view of things.]}, #"name": [footer]>,"tag"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"att-two"=[two],"att-one"=[one]}, #"name": [tag]>}, #"atts": {"alpha"=[apple],"bravo"=[bannanna],"charlie"=[carrot],"start"=Wi64<3>}, #"name": [doc]> att "alpha" has expected value "apple": [apple] - PASS NodeObj NodeObj<[ZERO/READY]#"children": {0={"list"=[[one],[two],[three]]},"footer"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"content"=[A secondary view of things.]}, #"name": [footer]>,"tag"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"att-two"=[two],"att-one"=[one]}, #"name": [tag]>}, #"atts": {"alpha"=[apple],"bravo"=[bannanna],"charlie"=[carrot],"start"=Wi64<3>}, #"name": [doc]> att "bravo" has expected value "bannanna": [bannanna] - PASS NodeObj NodeObj<[ZERO/READY]#"children": {0={"list"=[[one],[two],[three]]},"footer"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"content"=[A secondary view of things.]}, #"name": [footer]>,"tag"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"att-two"=[two],"att-one"=[one]}, #"name": [tag]>}, #"atts": {"alpha"=[apple],"bravo"=[bannanna],"charlie"=[carrot],"start"=Wi64<3>}, #"name": [doc]> att "charlie" has expected value "carrot": [carrot] - PASS NodeObj NodeObj<[ZERO/READY]#"children": {0={"list"=[[one],[two],[three]]},"footer"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"content"=[A secondary view of things.]}, #"name": [footer]>,"tag"=NodeObj<[ZERO/READY]#"children": {}, #"atts": {"att-two"=[two],"att-one"=[one]}, #"name": [tag]>}, #"atts": {"alpha"=[apple],"bravo"=[bannanna],"charlie"=[carrot],"start"=Wi64<3>}, #"name": [doc]> att "start" has expected value 3: Wi64<3> - PASS Tag node is not NULL: [doc,.,tag] - PASS NodeObj [doc,.,tag] att "att-one" has expected value "one": [one] - PASS NodeObj [doc,.,tag] att "att-two" has expected value "two": [two] - PASS Footer node is not NULL: [doc,.,footer] - PASS NodeObj [doc,.,tag] att "content" has expected value "A secondary view of things.": [A secondary view of things.] Mem 272k total/maxIdx=68/114 page-size=4096b === Testing: TemplCtx Tests TemplCtx tests of basic value templating. - PASS Roebling finished with state SUCCESS with keys - PASS Expected content found in example templ Mem 272k total/maxIdx=68/114 page-size=4096b === Testing: Templ Tests Testing templating with a few variables. - PASS Templ: Roebling finished with state SUCCESS with keys - PASS Templ_Prepare has result PROCESSING - PASS Templ key value test has expected content Mem 272k total/maxIdx=68/114 page-size=4096b === Testing: Encoding Tests Encoding tests for hex. - PASS Hex str is as expected Str, have Str - PASS From hex equals original str, expected Str, have Str Mem 272k total/maxIdx=68/114 page-size=4096b == Task/Serve Tests === Testing: Queue Tests Queue tests for file descriptors. - PASS Queue idx is on added item, expected 3, have 3 for Queue<[SUCCESS] 0001000000000000000000000000000000000000000000000000000000000000 1nvalues> - PASS Queue item is first item, expected Str, have Str Mem 276k total/maxIdx=69/114 page-size=4096b === Testing: Queue Add Remove Tests Queue tests for adding and removing items. - PASS Queue has the 0th item available - PASS No items after first item is removed - PASS first item is in the first slot - PASS first item is in the first slot, expected "Alpha", have "Alpha" - PASS Expected "Alpha" = "Alpha", "Bravo" = "Bravo", "Charlie" = "Charlie" - PASS Expected "Alpha" = "Alpha", null(NULL) = null(NULL), "Charlie" = "Charlie" - PASS Expected "Alpha" = "Alpha", "Bravo-two" = "Bravo-two", "Charlie" = "Charlie" Mem 280k total/maxIdx=70/114 page-size=4096b === Testing: Queue Iter Tests Queue tests for iterating around a queue with additions and removals. - PASS Empty Queue_Next returns END flag - PASS Queue item matches, expected "One", have "One" - PASS Queue runs for the number of items in it, have 1, for Queue<[END] 0000000000000000000000000000000000000000000000000000000000000000 1nvalues> - PASS Queue item matches, expected "One", have "One" - PASS Queue item matches, expected "Two", have "Two" - PASS Queue item matches, expected "Three", have "Three" - PASS Queue item matches, expected "Four", have "Four" - PASS Queue item matches, expected "Five", have "Five" - PASS Queue runs for the number of items in it, have 5, for Queue<[END] 0000000000000000000000000000000000000000000000000000000000000000 5nvalues> - PASS Queue item matches, expected "One", have "One" - PASS Queue item matches, expected "Two", have "Two" - PASS Queue item matches, expected "Three", have "Three" - PASS Queue item matches, expected NULL, have NULL - PASS Queue item matches, expected "Five", have "Five" - PASS Queue item matches, expected "One", have "One" - PASS Queue item matches, expected "Two", have "Two" - PASS Queue item matches, expected "Three", have "Three" - PASS Queue item matches, expected "Four-two", have "Four-two" - PASS Queue item matches, expected "Five", have "Five" - PASS Queue runs for the number of items in it, have 5, for Queue<[END] 0000000000000000000000000000000000000000000000000000000000000000 5nvalues> Mem 292k total/maxIdx=73/114 page-size=4096b === Testing: Queue Criteria Tests Queue tests for multi-critiria items (time/file descriptor). - PASS No items will run at the presetn time, flags [END] - PASS Queue item matches, expected "Three Seconds", have "Three Seconds" - PASS Only one item was available to run, i is 1, at 4 seconds from start - PASS Queue item matches, expected "Three Seconds", have "Three Seconds" - PASS Queue item matches, expected "Ten Minutes", have "Ten Minutes" - PASS Only one item was available to run, i is 2, at 15 minutes from start - PASS Queue item matches, expected "Two Days", have "Two Days" - PASS Queue item matches, expected "Three Seconds", have "Three Seconds" - PASS Queue item matches, expected "Ten Minutes", have "Ten Minutes" - PASS Only one item was available to run, i is 3, at 3 days from start - PASS Queue item matches, expected "File Descriptor", have "File Descriptor" - PASS Queue item matches, expected "Three Seconds", have "Three Seconds" - PASS PollFd set to Read: two item was available to run, i is 2, at 10 seconds from start - PASS Queue item matches, expected "Three Seconds", have "Three Seconds" - PASS No direction set on pollfd: Only one item was available to run, i is 1, at 10 seconds from start Mem 296k total/maxIdx=74/114 page-size=4096b === Testing: Queue Scale Tests Queue testing adding and removing Queue items over time. - PASS Expected q->go to be set to binary 0000000000000000100000001000000000000000000000000000000000000001 of 16,24, and 63, have 0000000000000000100000001000000000000000000000000000000000000001 - PASS Expected value above first slab found, have "Not Cool...", in Queue<[SUCCESS] 0000000000000000100000001000000000000000000000000000000000000001 5nvalues> - PASS Expected q->go to be set to binary 0000000000000000100000001000000000000000000000000000000000000001 of 1 << 16 - PASS Expected value above first slab found, have "Hidy Ho!", in Queue<[SUCCESS] 0000000000000000100000001000000000000000000000000000000000000001 5nvalues> - PASS Expected q->go to be set to binary 0000000000000000100000001000000000000000000000000000000000000001 of 1 << 24 - PASS Expected value above first slab found, have "Livin on the Edge!", in Queue<[SUCCESS] 0000000000000000100000001000000000000000000000000000000000000001 5nvalues> - PASS Expected q->go to be set to binary 0000000000000000100000001000000000000000000000000000000000000001 of 1 << 63 - PASS Expected value above first slab found, have "XjfoaiwuerZduio", in Queue<[SUCCESS] 1100000000000000000000000000000000000000000000000000000000000000 5nvalues> - PASS Expected q->go to be set to binary 1100000000000000000000000000000000000000000000000000000000000000 of 1 << 64 - PASS Expected value above first slab found, have "SixyFivey", in Queue<[SUCCESS] 1100000000000000000000000000000000000000000000000000000000000000 5nvalues> - PASS Expected q->go to be set to binary 1100000000000000000000000000000000000000000000000000000000000000 of 1 << 65 - PASS All 10 Queue items were handled - PASS Max 10 scale tests finish with SUCCESS - PASS All 57 Queue items were handled - PASS Max 57 scale tests finish with SUCCESS - PASS All 66 Queue items were handled - PASS Max 66 scale tests finish with SUCCESS - PASS All 432 Queue items were handled - PASS Max 432 scale tests finish with SUCCESS - PASS All 777 Queue items were handled - PASS Max 777 scale tests finish with SUCCESS Mem 304k total/maxIdx=76/114 page-size=4096b === Testing: TaskStep Tests Task/Step and Task_Tumble tests. - PASS Source str equals tsk->source with expected count 0 - PASS Source str equals tsk->source with expected count 1 - PASS Source str equals tsk->source with expected count 2 - PASS Task finishes successfully Mem 304k total/maxIdx=76/114 page-size=4096b == ThirdParty/Api === Testing: Crypto Tests Cryptography functionality testing. - PASS Str Sha256 Matches, expected "Yay test string!" -> 8a87db5fb3a1e4491a04644396437064375c00bdaf7fea33bd4645ba138539b5, have 8a87db5fb3a1e4491a04644396437064375c00bdaf7fea33bd4645ba138539b5 - PASS StrVec and Str text are identical: Str vs Str - PASS StrVec Sha256 Matches Str -> "8a87db5fb3a1e4491a04644396437064375c00bdaf7fea33bd4645ba138539b5" - PASS longstr Str Sha256 matches, expected "da43c4b3c5e3667dcaf17f184880241908c2ab1f9e8d2f5bbf62825df6303ab6", have "da43c4b3c5e3667dcaf17f184880241908c2ab1f9e8d2f5bbf62825df6303ab6" - PASS StrVec Sha256 matches, expected "da43c4b3c5e3667dcaf17f184880241908c2ab1f9e8d2f5bbf62825df6303ab6", have "da43c4b3c5e3667dcaf17f184880241908c2ab1f9e8d2f5bbf62825df6303ab6" - PASS Salted StrVec Sha256 matches, expected "466b336b19f46a9684b4515f43ac4b3a06e080369f99394434e4b8d4f4cbc9de", have "466b336b19f46a9684b4515f43ac4b3a06e080369f99394434e4b8d4f4cbc9de" - PASS Public and public second generation are equals - PASS Secret and secret second generation are equals - PASS Message validates: "I super-master person, do hereby sign some cool, super-fancy stuff, that totally needed to be signed, like yesterday (sorry)" -> sig:"a7db7f39eaa5b86c84a51acc4ba002abb52938b1832b86f72a4e7d4dfbe669262f6357f2bed47ccf5fcd592c20156066fedfd5d245998f5620fab1d56430e76511997d145f8f6f8b268f0d3423214c05c70bf6463861ecf2c16378920da31f05" Mem 308k total/maxIdx=77/114 page-size=4096b === Testing: Inet Tests Inet address translation tests. - PASS From Str to quad and back matches, expected 10.1.255.7, have 10.1.255.7 - PASS From quad to Str matches, expected 01010000100000001111111111100000, have 01010000100000001111111111100000 - PASS From four sepeate bytes to quad matches, expected 01010000100000001111111111100000, have 01010000100000001111111111100000 Mem 308k total/maxIdx=77/114 page-size=4096b == Www Tests === Testing: Www Route Tests Testing an object that gathers and caches routes for web servers. - PASS Route for [/,tests] is not NULL - PASS account tests page is mime type html, have "text/html" - PASS account tests page is type fmt, have [fmt] - PASS profile stat page is mime type text/html - PASS profile stat page is mime type templ, have "text/html" Mem 312k total/maxIdx=78/224 page-size=4096b === Testing: Www Route Template Tests Example route templating test. - PASS Templ from Route has expected output - PASS Handler: Expected template value with no header and mem details - PASS Footer: Expected template value with no mem object and a header - PASS Expected mem details in template - PASS Default / handler is not null - PASS Expected fmt value Mem 320k total/maxIdx=80/392 page-size=4096b === Testing: Www Path Tests Example route path templating test. - PASS Route has expected file expected [/,basic,/,caneka-checkout,/,examples,/,web-server,/,pages,/,static,/,logo-transparent-white_256,.,png], found [/basic/caneka-checkout/examples/web-server/pages/static,/,logo-transparent-white_256,.,png] - PASS Route has expected file expected [/,basic,/,caneka-checkout,/,examples,/,web-server,/,pages,/,public,/,index,.,fmt], found [/basic/caneka-checkout/examples/web-server/pages/public,/,index,.,fmt] - PASS Route has expected file expected [/,basic,/,caneka-checkout,/,examples,/,web-server,/,pages,/,system,/,not-found,.,templ], found [/basic/caneka-checkout/examples/web-server/pages/system,/,not-found,.,templ] Mem 324k total/maxIdx=81/392 page-size=4096b === Testing: Www Route Mime Tests Example route mime handling tests using Route_Handle. - PASS Static route is not null - PASS Content from Buff piped from route matches reading file directly Mem 328k total/maxIdx=82/392 page-size=4096b Suite Caneka pass(62) fail(0)