1## 2## set8700 - dotest line tests for the 8700 set of regress.cal 3## 4## Copyright (C) 2006,2021 Ernest Bowen and Landon Curt Noll 5## 6## Calc is open software; you can redistribute it and/or modify it under 7## the terms of the version 2.1 of the GNU Lesser General Public License 8## as published by the Free Software Foundation. 9## 10## Calc is distributed in the hope that it will be useful, but WITHOUT 11## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 12## or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General 13## Public License for more details. 14## 15## A copy of version 2.1 of the GNU Lesser General Public License is 16## distributed with calc under the filename COPYING-LGPL. You should have 17## received a copy with calc; if not, write to Free Software Foundation, Inc. 18## 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 19## 20## Under source code control: 2006/05/20 14:10:11 21## File existed as early as: 2006 22## 23## chongo <was here> /\oo/\ http://www.isthe.com/chongo/ 24## Share and enjoy! :-) http://www.isthe.com/chongo/tech/comp/calc/ 25 26 27strcpy("", "") == "" 28strcpy("", "xyz") == "" 29strcpy("a", "xyz") == "x" 30strcpy("ab", "xyz") == "xy" 31strcpy("abc", "xyz") == "xyz" 32strcpy("abcd", "xyz") == "xyz\0" ## Result will print as "xyz" 33strcpy("abcde", "xyz") == "xyz\0e" 34strcpy("abcdef", "xyz") == "xyz\0ef" 35strcpy("abcdef", "x\0z") == "x\0z\0ef" ## Note z is copied 36strcpy("abc", "") == "\0bc" 37 38strncpy("abcdef", "xyz", 0) == "abcdef" ## No characters copied 39strncpy("abcdef", "xyz", 1) == "xbcdef" ## One character copied, no '\0' 40strncpy("abcdef", "xyz", 2) == "xycdef" 41strncpy("abcdef", "xyz", 3) == "xyzdef" 42strncpy("abcdef", "xyz", 4) == "xyz\0ef" 43strncpy("abcdef", "xyz", 5) == "xyz\0\0f" ## Two nulls as in C 44strncpy("abcdef", "xyz", 6) == "xyz\0\0\0" 45strncpy("abcdef", "xyz", 7) == "xyz\0\0\0" ## Size of first string unchanged 46strncpy("a\0cdef", "\0yz", 4) == "\0yz\0ef" 47strncpy("ab", "xyz", 3) == "xy" 48 49strcmp("", "") == 0 50strcmp("", "a") == -1 51strcmp("\n", "\n") == 0 52strcmp("\0", "") == 1 ## '\0' treated like other characters 53strcmp("ab", "") == 1 54strcmp("ab", "a") == 1 55strcmp("ab", "ab") == 0 56strcmp("ab", "abc") == -1 57strcmp("abc", "abb") == 1 58strcmp("abc", "abc") == 0 59strcmp("abc", "abd") == -1 60strcmp("abc\0", "abc") == 1 61 62strncmp("abc", "xyz", 0) == 0 63strncmp("abc", "xyz", 1) == -1 64strncmp("abc", "", 1) == 1 65strncmp("abc", "a", 1) == 0 66strncmp("", "", 2) == 0 67strncmp("a", "a", 2) == 0 68strncmp("a", "b", 2) == -1 69strncmp("ab", "ab", 2) == 0 70strncmp("ab", "ac", 2) == -1 71strncmp("\0ac", "\0b", 2) == -1 72strncmp("ab", "abc", 2) == 0 73strncmp("abc", "abd", 2) == 0 74strncmp("a", "a\0", 2) == -1 75strncmp("a", "a", 3) == 0 76strncmp("abc", "abd", 3) == -1 77strncmp("\0\0\n", "\0\0\t", 3) == 1 78 79str("abc") == "abc" 80str("ab\0") == "ab" 81str("a\0c") == "a" 82str("\0bc") == "" 83 84size("") == 0 85size("a") == 1 86size("\0") == 1 87size("a\0") == 2 88size("a\0b") == 3 89 90strlen("\0") == 0 91strlen("a\0") == 1 92strlen("a\0b") == 1 93 940 * "abc" == "" 951 * "abc" == "abc" 962 * "abc" == "abcabc" 973 * "abc" == "abcabcabc" 981 * "" == "" 99-1 * "abc" == "cba" 100-2 * "abc" == "cbacba" 101"abc" + "xyz" == "abcxyz" 102"abc" - "xyz" == "abczyx" 103 104 105substr("abcd",0,0) == "" 106substr("abcd",0,1) == "a" 107substr("abcd",0,2) == "ab" 108substr("abcd",1,0) == "" 109substr("abcd",1,1) == "a" 110substr("abcd",1,2) == "ab" 111substr("abcd",2,0) == "" 112substr("abcd",2,1) == "b" 113substr("abcd",2,2) == "bc"; 114substr("abcd",2,3) == "bcd"; 115substr("abcd",2,4) == "bcd"; 116substr("abcd",2,5) == "bcd"; ## substr stops at end of string 117substr("abcd",4,0) == "" 118substr("abcd",4,1) == "d" 119substr("abcd",4,2) == "d" 120substr("abcd",4,3) == "d" 121substr("abcd",5,0) == "" 122substr("abcd",5,1) == "" 123substr("a\0c\0",2,2) == "\0c" ## '\0' treated like other characters 124substr("a\0c\0",2,3) == "\0c\0" 125 126#"" == 0 ## # operator counts number of bits 127#"\0" == 0 128# "a" == 3 129 # "ab" == 6 ## white space ignored 130# "abc" == 10 131# 27 == 4 132# 0b1010111011 == 7 133 1347 # 9 == 2 ## 7 # 9 = abs(7 - 9) 1353/4 # 2/3 == 1/12 136 137a = 5, a #= 2, a == 3 138a #= 4, a == 1 139 140## Binary # operator not defined for strings 141 142protect(set8700_A) == 0 143## Testing with one lvalue 144isnull(protect(set8700_A,65)) 145protect(set8700_A) == 65 146isnull(protect(set8700_A, -1)) 147protect(set8700_A) == 64 148protect(set8700_A,-2), protect(set8700_A) == 64 149protect(set8700_A,5), protect(set8700_A) == 69 150protect(set8700_A,-4), protect(set8700_A) == 65 151protect(set8700_A,0), protect(set8700_A) == 0 152protect(set8700_A,1234), protect(set8700_A) == 1234 153protect(set8700_A,-1234), protect(set8700_A) == 0 154protect(set8700_A,65535), protect(set8700_A) == 65535 155protect(set8700_A,-65535), protect(set8700_A) == 0 156 157## Simple assignments 158set8700_A = 42, protect(set8700_A,1024), set8700_B = set8700_A, protect(set8700_B) == 1024 159set8700_A = 6 * 7, protect(set8700_A) == 1024 160set8700_A == set8700_B 161 162## Testing matrix protection 163set8700_A = mat [3] = {1, 2, list(3,4)}; 1 164protect(set8700_A, 65, 1), protect(set8700_A) == 1089 165protect(set8700_A[0]) == 65 166protect(set8700_A[2]) == 65 167protect(set8700_A[2][1]) == 0 168protect(set8700_A, 65, 2), protect(set8700_A[2][1]) == 65 169protect(set8700_A,-1024), protect(set8700_A) == 65 170protect(set8700_A, -1, 1), protect(set8700_A) == 64 171protect(set8700_A[1]) == 64 172protect(set8700_A[2]) == 64 173protect(set8700_A[2][0]) == 65 174protect(set8700_A,0), protect(set8700_A) == 0 175protect(set8700_A[1]) == 64 176protect(set8700_A, 0, 2), protect(set8700_A) == 0 177protect(set8700_A[1]) == 0 178protect(set8700_A[2][1]) == 0 179protect(set8700_A,1024, 2), protect(set8700_A) == 1024 180protect(set8700_A[2]) == 1024 181protect(set8700_A[2][0], 512), protect(set8700_A[2][0]) == 1536 182 183## Testing simple assignment of matrix 184set8700_B = set8700_A, protect(set8700_B) == 1024 ## protect(set8700_A) copied 185protect(set8700_B[2]) == 1024 ## protect(set8700_A[2]) copied 186protect(set8700_B[2][0]) == 1536 ## protect(set8700_A[2][0]) copied 187 188## copying matrix to list 189set8700_B = list(5,6,7), protect(set8700_B) == 1024 190protect(set8700_B[0]) == 0 191protect(set8700_B[2]) == 0 192protect(set8700_A,0), protect(set8700_A) == 0 193copy(set8700_A,set8700_B), set8700_B[0] == 1 && set8700_B[1] == 2 194set8700_B[2] == list(3,4) 195protect(set8700_B) == 1024 ## protect(set8700_A) not copied 196protect(set8700_B[0]) == 1024 ## protect(set8700_A[0]) copied 197protect(set8700_B[2][0]) == 1536 ## protect(set8700_A[2][0]) copied 198 199## copying matrix to matrix 200set8700_B = mat[3], protect(set8700_B) == 1024 201protect(set8700_B[2]) == 0 202copy(set8700_A,set8700_B), set8700_B[0] == 1 && set8700_B[1] == 2 203set8700_B[2] == list(3,4) 204protect(set8700_B) == 1024 ## protect(set8700_A) not copied 205protect(set8700_B[0]) == 1024 ## protect(set8700_A[0]) copied 206protect(set8700_B[2][0]) == 1536 ## protect(set8700_A[2][0]) copied 207 208## Testing list protection 209set8700_A = list(1, 2, list(3,4)), 1 210protect(set8700_A,1024, 2), protect(set8700_A) == 1024 211protect(set8700_A[2]) == 1024 212protect(set8700_A[2][0], 512), protect(set8700_A[2][0]) == 1536 213 214## Simple assignment of list 215set8700_B = set8700_A, protect(set8700_B) == 1024 ## protect(set8700_A) copied 216protect(set8700_B[2]) == 1024 ## protect(set8700_A[2]) copied 217protect(set8700_B[2][0]) == 1536 ## protect(set8700_A[2][0]) copied 218 219## Copying list to list 220set8700_B = list(5,6,7), protect(set8700_B) == 1024 221protect(set8700_B[2]) == 0 222copy(set8700_A,set8700_B), set8700_B[0] == 1 && set8700_B[1] == 2 223set8700_B[2] == list(3,4) 224protect(set8700_B) == 1024 ## protect(set8700_A) not copied 225protect(set8700_B[0]) == 1024 ## protect(set8700_A[0]) copied 226protect(set8700_B[2][0]) == 1536 ## protect(set8700_A[2][0]) copied 227 228## Copying list to matrix 229set8700_B = mat[3], protect(set8700_B) == 1024 230protect(set8700_B[2]) == 0 231copy(set8700_A,set8700_B), set8700_B[0] == 1 && set8700_B[1] == 2 232set8700_B[2] == list(3,4) 233protect(set8700_B) == 1024 234protect(set8700_B[0]) == 1024 ## protect(set8700_A[0]) copied 235protect(set8700_B[2][0]) == 1536 ## protect(set8700_A[2][0]) copied 236 237## Protecting one element of a list 238set8700_A = list(1,4,3,2), protect(set8700_A[1]) == 0 239protect(set8700_A[1], 1024), protect(set8700_A[1]) == 1024 240 241## Testing sort 242set8700_A = sort(set8700_A), set8700_A == list(1,2,3,4) 243protect(set8700_A[1]) == 0 244protect(set8700_A[3]) == 1024 ## status of 4 245 246## Testings reverse 247set8700_A = reverse(set8700_A), set8700_A == list(4,3,2,1) 248protect(set8700_A[0]) == 1024 ## status of 4 249 250## Testing swap 251swap(set8700_A[0], set8700_A[1]), set8700_A == list(3,4,2,1) 252protect(set8700_A[0]) == 0 ## status moved 253protect(set8700_A[1]) == 1024 ## 4 retains protection 254 255## Testing list with protected list argument 256protect(set8700_A, 0), protect(set8700_A) == 0 257protect(set8700_A, 512), protect(set8700_A) == 512 258protect(set8700_A[1]) == 1024 259set8700_L = list(1,set8700_A,3), protect(set8700_L) == 0 260protect(set8700_L[0]) == 0 261protect(set8700_L[1]) == 512 ## protect(set8700_A) copied 262protect(set8700_L[1][1]) == 1024 ## protect(set8700_A[1]) copied 263 264## Testing list with "initialization" 265set8700_L = list(1,2,3), protect(set8700_L) == 0 266protect(set8700_L[0]) | protect(set8700_L[1]) | protect(set8700_L[2]) == 0 ## All zero 267set8700_L = {1,set8700_A}, set8700_L[1] == set8700_A 268protect(set8700_L[1]) == 512 ## protect(set8700_A) copied 269protect(set8700_L[1][1]) == 1024 ## protect(set8700_A[1]) copied 270set8700_L[1] = 2, protect(set8700_L[1]) == 512 ## Not changed 271 272## Testing matrix with "initialization" 273set8700_M = mat[3] = {1,set8700_A}, protect(set8700_M) == 0 274protect(set8700_M[0]) == 0 275protect(set8700_M[1]) == 512 ## protect(set8700_A) copied 276protect(set8700_M[2]) == 0 277protect(set8700_M[1][1]) == 1024 ## protect(set8700_A[1]) copied 278 279## Testing push, pop, append, remove 280set8700_A = list(1,2), protect(set8700_A,0,1), protect(set8700_A[0]) == 0 281protect(set8700_A[0], 256), protect(set8700_A[0]) == 256 282protect(set8700_A[1]) == 0 283append(set8700_A, pop(set8700_A)), protect(set8700_A[0]) == 0 284protect(set8700_A[1]) == 256 285push(set8700_A, remove(set8700_A)), protect(set8700_A[0]) == 256 286protect(set8700_A[1]) == 0 287 288## Testing operation-assignments 289set8700_A = 5, protect(set8700_A,1024), protect(set8700_A) == 1024 290protect(set8700_A, 1024), set8700_A = 7, protect(set8700_A) == 1024 291protect(set8700_A,1024), set8700_A += 2, protect(set8700_A) == 1024 292protect(set8700_A,1024), set8700_A *= 2, protect(set8700_A) == 1024 293protect(set8700_A,1024), set8700_A |= 2, protect(set8700_A) == 1024 294protect(set8700_A,1024), set8700_A &= 2, protect(set8700_A) == 1024 295protect(set8700_A,1024), set8700_A ^= 2, protect(set8700_A) == 1024 296 297protect(set8700_B,0), set8700_B = set8700_getA1(), protect(set8700_B) == 1024 298protect(set8700_B,0), set8700_B = set8700_getA2(), protect(set8700_B) == 1024 299set8700_B = set8700_getvar(), protect(set8700_B) == 1024 + 256 300 301set8700_x = 7, protect(set8700_x) == 0 302protect(7,2) == error(10234) 303protect(set8700_x,2.5) == error(10235) 304protect(set8700_x,"abc") == error(10235) 305protect(set8700_x, 1e6) == error(10235) 306protect(set8700_x,1), (set8700_x = 2) == error(10366) 307(set8700_x = 3 + 4) == error(10366) 308 309protect(set8700_x,2), protect(set8700_x) == 3 310protect(set8700_x,-1), protect(set8700_x) == 2 311(set8700_x = 2) == error(10368) 312(set8700_x = 3 + 4) == 7 313protect(set8700_x,2), ++set8700_x == error(10379) 314set8700_x == 7 315--set8700_x == error(10382) 316set8700_x == 7 317set8700_x++ == error(10385) 318set8700_x == 7 319set8700_x-- == error(10388) 320 321protect(set8700_A,0), protect(set8700_A,16), 1 322set8700_A = "abcdef", protect(set8700_A) == 16 ## No copy to set8700_A 323protect(set8700_B,0), set8700_B = "xyz", protect(set8700_B) == 0 324copy(set8700_B, set8700_A) == error(10226) 325set8700_A == "abcdef" ## set8700_A not changed 326protect(set8700_A,0), copy(set8700_B,set8700_A), set8700_A == "xyzdef" 327protect(set8700_B,128), protect(set8700_B) == 128 ## No copy from set8700_B 328copy(set8700_B,set8700_A,,,3) == error(10225) 329set8700_A == "xyzdef" 330protect(set8700_B,0), copy(set8700_B,set8700_A,,,3), set8700_A == "xyzxyz" 331 332set8700_A = "abcdef", protect(set8700_A, 16), swap(set8700_A[0], set8700_A[5]) == error(10371) 333set8700_A == "abcdef" 334protect(set8700_A,0), isnull(swap(set8700_A[0], set8700_A[5])) 335set8700_A == "fbcdea" 336protect(set8700_A,2), ++set8700_A[0] == error(10377) 337--set8700_A[1] == error(10380) 338set8700_A[2]++ == error(10383) 339set8700_A[3]-- == error(10386) 340set8700_A == "fbcdea" 341protect(set8700_A,0), ++set8700_A[0] == 'g' 342--set8700_A[1] == 'a' 343set8700_A[2]++ == ord('c') 344set8700_A[3]-- == ord('d') 345set8700_A == "gadcea" 346 347protect(set8700_x,0), protect(set8700_y,0), protect(set8700_x,256), protect(set8700_y,512),1 348quomod(11,4,set8700_x,set8700_y), set8700_x == 2 && set8700_y == 3 349protect(set8700_x) == 256 350protect(set8700_y) == 512 351 352set8700_A = mat[3]; protect(set8700_A[0], 1024); protect(set8700_A[0]) == 1024 353set8700_x = 7, protect(set8700_x,0), protect(set8700_x, 512), 1 354set8700_A = {set8700_x,,set8700_x}, protect(set8700_A[0]) == 1536 355protect(set8700_A[1]) == 0 356protect(set8700_A[2]) == 512 357protect(set8700_A,16), protect(set8700_A) == 16 ## No copy to 358set8700_A == (mat[3] = {7,0,7}) 359set8700_A = {1,2,3}, errno() == 10390; 360set8700_A == (mat[3] = {7,0,7}) 361 362protect(set8700_A,0), set8700_A = {1,2,3}, set8700_A == (mat[3] = {1,2,3}) 363protect(set8700_A[1],1), protect(set8700_A[1]) == 1 364set8700_A = {4,5,6}, errno() == 10394 365set8700_A == (mat[3] = {4,2,6}) 366modify(7, "set8700_f") == error(10405) 367set8700_A = list(2,3,5), modify(set8700_A, 7) == error(10406) 368protect(set8700_A,2), modify(set8700_A, "set8700_f") == error(10407) 369protect(set8700_A,0), modify(set8700_A, "h") == error(10408) 370set8700_B = 42, protect(set8700_B,0), modify(set8700_B, "set8700_f") == error(10409) 371set8700_A == list(2,3,5) ## set8700_A not affected by failures 372protect(set8700_A,0,1), modify(set8700_A, "set8700_f") == null() 373set8700_A == list(4,9,25) 374modify(set8700_A,"set8700_g") == null() 375protect(set8700_A[0]) == 0 376protect(set8700_A[1]) == 256 && protect(set8700_A[2]) == 256 377 378set8700_A = 0, protect(set8700_A,0), set8700_A = pop(2), set8700_A == error(10181) 379set8700_A = pop(list(1,2,3)), set8700_A == error(10181) 380set8700_B = set8700_A = pop(2), set8700_B == error(10181) 381set8700_A = 32, protect(set8700_A,8), (set8700_A = pop(2)) == error(10370) 382set8700_A == 32 383set8700_B = set8700_A = pop(2), set8700_B == error(10370) 384## Testing copying of protected elements and initialization 385set8700_M1 = mat[3], protect(set8700_M1,0), protect(set8700_M1[1],1), protect(set8700_M1[1]) == 1 386set8700_M2 = mat[3], protect(set8700_M2,0), protect(set8700_M2[2],4), protect(set8700_M2[2]) == 4 387set8700_L = list(set8700_M1, set8700_M2), protect(set8700_L[0][1]) == 1 && protect(set8700_L[1][2]) == 4 388set8700_L = {{1,2,3},{'a','b','c'}}, set8700_L[0] == (mat[3] = {1,0,3}) 389set8700_L[1] == (mat[3] = {'a','b',0}) 390set8700_M = mat[2], protect(set8700_M,0), set8700_M = {1,2,3,4}, set8700_M == (mat[2] = {1,2}) 391set8700_x = 5, set8700_M = {set8700_x++, set8700_x++, set8700_x++, set8700_x++, set8700_x++}, set8700_M == (mat[2] = {5,6}) 392set8700_x == 10 ## All initialization terms evaluated 393set8700_S = " ", set8700_S = {'a','b','c','d'}, set8700_S == "abc" 394 395set8700_P = obj set8700_point = {1,2,3,4}, set8700_P.set8700_x == 1 && set8700_P.set8700_y == 2 && set8700_P.set8700_z == 3 396protect(set8700_P,16), set8700_Q = set8700_P, set8700_Q = {5,6,7}, set8700_Q == set8700_P 397set8700_P == (obj set8700_point = {1,2,3}) 398set8700_L = list(mat[1] = {set8700_P}), protect(set8700_L[0][0]) == 16 399set8700_L = {{{4,5,6}}}, set8700_L[0][0] == set8700_P 400protect(set8700_L,0,2), set8700_L = {{{4,5,6}}}, set8700_L[0][0] == (obj set8700_point = {4,5,6}) 401 402## Testing quomod 403quomod(14,5,3,4) == error(10374) 404global set8700_a,set8700_b; quomod("abc", 4, set8700_a, set8700_b) == error(10375) 405quomod(14,5,set8700_a,set8700_b,0) == 1 && set8700_a == 2 && set8700_b == 4 406quomod(14,5,set8700_a,set8700_b,1) == 1 && set8700_a == 3 && set8700_b == -1 407quomod("abc",2,set8700_a,set8700_b) == error(10375) 408set8700_a = "abc"; quomod(14,5,set8700_a,set8700_b) == error(10375) 409set8700_a = null(); quomod(14,5,set8700_a,set8700_b,24) == 1; set8700_a == 3 && set8700_b == -1 410quomod(14,5,set8700_a,set8700_a) == error(10374) 411quomod(14,5,set8700_a,set8700_b,-1) == error(10375) 412protect(set8700_a,1); quomod(17,2,set8700_a,set8700_b) == error(10376) 413protect(set8700_a,0); quomod(17,2,set8700_a,set8700_b); set8700_a == 8 && set8700_b == 1 414set8700_p = &set8700_a, set8700_q = &set8700_b; quomod(14,5,*set8700_p,*set8700_q); *set8700_p == 2 && *set8700_q == 4 415 416## Testing estr 417base(1/3) == 10 418strcmp(estr(null()), "\"\"") == 0 419strcmp(estr(bernoulli(48)), "-5609403368997817686249127547/46410") == 0 420strcmp(estr(sin(3i)), "1001787492740990189897i/100000000000000000000") == 0 421base(10) == 1/3 422strcmp(estr("fizzbin"), "\"fizzbin\"") == 0 423strcmp(estr(set8700_c), "mat[5]={1,2+3i,-5+4i,6+5i,-7i}") == 0 424strcmp(estr(set8700_e), "mat[16]={0,1,0,0,2,-3/2,2,-1/2,-3,1/2,-1,1/2,1,0,0,0}") == 0 425strcmp(estr(list(2,3,5)), "list(2,3,5)") == 0 426